linux sock_raw原始套接字编程

最新推荐文章于 2024-11-11 22:04:04 发布
最新推荐文章于 2024-11-11 22:04:04 发布
阅读量841 收藏
点赞数
分类专栏： 杂文 linux 文章标签： 编程 linux struct socket interface null
杂文 同时被 2 个专栏收录
54 篇文章 1 订阅
订阅专栏
linux
36 篇文章 0 订阅
订阅专栏
 

sock_raw原始套接字编程可以接收到本机网卡上的数据帧或者数据包,对与监听网络的流量和分析是很有作用的.一共可以有3种方式创建这种socket
1.socket(AF_INET, SOCK_RAW, IPPROTO_TCP|IPPROTO_UDP|IPPROTO_ICMP)发送接收ip数据包
2.socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP|ETH_P_ARP|ETH_P_ALL))发送接收以太网数据帧
3.socket(AF_INET, SOCK_PACKET, htons(ETH_P_IP|ETH_P_ARP|ETH_P_ALL))过时了,不要用啊
理解一下SOCK_RAW的原理, 比如网卡收到了一个 14+20+8+100+4 的udp的以太网数据帧.
首先,网卡对该数据帧进行硬过滤(根据网卡的模式不同会有不同的动作,如果设置了promisc混杂模式的话,则不做任何过滤直接交给下一层输入例程,否则非本机mac或者广播mac会被直接丢弃).按照上面的例子,如果成功的话,会进入ip输入例程.但是在进入ip输入例程之前,系统会检查系统中是否有通过socket(AF_PACKET, SOCK_RAW, ..)创建的套接字.如果有的话并且协议相符,在这个例子中就是需要ETH_P_IP或者ETH_P_ALL类型.系统就给每个这样的socket接收缓冲区发送一个数据帧拷贝.然后进入下一步.
其次,进入了ip输入例程(ip层会对该数据包进行软过滤,就是检查校验或者丢弃非本机ip或者广播ip的数据包等,具体要参考源代码),例子中就是如果成功的话会进入udp输入例程.但是在交给udp输入例程之前,系统会检查系统中是否有通过socket(AF_INET, SOCK_RAW, ..)创建的套接字.如果有的话并且协议相符,在这个例子中就是需要IPPROTO_UDP类型.系统就给每个这样的socket接收缓冲区发送一个数据帧拷贝.然后进入下一步.
最后,进入udp输入例程 ...
ps:如果校验和出错的话,内核会直接丢弃该数据包的.而不会拷贝给sock_raw的套接字,因为校验和都出错了,数据肯定有问题的包括所有信息都没有意义了.
进一步分析他们的能力.
1. socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
能:该套接字可以接收协议类型为(tcp udp icmp等)发往本机的ip数据包,从上面看的就是20+8+100.
不能:不能收到非发往本地ip的数据包(ip软过滤会丢弃这些不是发往本机ip的数据包).
不能:不能收到从本机发送出去的数据包.
发送的话需要自己组织tcp udp icmp等头部.可以setsockopt来自己包装ip头部
这种套接字用来写个ping程序比较适合
    
2. socket(PF_PACKET, SOCK_RAW, htons(x)); 
这个套接字比较强大,创建这种套接字可以监听网卡上的所有数据帧.从上面看就是20+20+8+100.最后一个以太网crc从来都不算进来的,因为内核已经判断过了,对程序来说没有任何意义了.
能: 接收发往本地mac的数据帧
能: 接收从本机发送出去的数据帧(第3个参数需要设置为ETH_P_ALL)
能: 接收非发往本地mac的数据帧(网卡需要设置为promisc混杂模式)
协议类型一共有四个
ETH_P_IP  0x800      只接收发往本机mac的ip类型的数据帧
ETH_P_ARP 0x806      只接受发往本机mac的arp类型的数据帧
ETH_P_ARP 0x8035     只接受发往本机mac的rarp类型的数据帧
ETH_P_ALL 0x3        接收发往本机mac的所有类型ip arp rarp的数据帧, 接收从本机发出的所有类型的数据帧.(混杂模式打开的情况下,会接收到非发往本地mac的数据帧)
发送的时候需要自己组织整个以太网数据帧.所有相关的地址使用struct sockaddr_ll 而不是struct sockaddr_in(因为协议簇是PF_PACKET不是AF_INET了),比如发送给某个机器,对方的地址需要使用struct sockaddr_ll.
这种socket大小通吃,强悍
下面是一段相关的代码:

    ...
    int sockfd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    struct sockaddr_ll sll;
    memset( &sll, 0, sizeof(sll) );
    sll.sll_family = AF_PACKET;
    struct ifreq ifstruct;
    strcpy(ifstruct.ifr_name, "eth0");
    ioctl(sockfd, SIOCGIFINDEX, &ifstruct);
    sll.sll_ifindex = ifstruct.ifr_ifindex;
    sll.sll_protocol = htons(ETH_P_ALL);
    if(bind(fd, (struct sockaddr *) &sll, sizeof(sll)) == -1 ) {
       perror("bind()");
    ...

int set_promisc(char *interface, int fd) {
        struct ifreq ifr;
        strcpy(ifr.ifr_name, interface);
        if(ioctl(fd, SIOCGIFFLAGS, &ifr) == -1) {
                perror("iotcl()");
                return -1;
        }
        ifr.ifr_flags |= IFF_PROMISC;
        if(ioctl(fd, SIOCSIFFLAGS, &ifr) == -1) {
                perror("iotcl()");
                return -1;
        }
        return 0;
}

int unset_promisc(char *interface, int fd) {
        struct ifreq ifr;
        strcpy(ifr.ifr_name, interface);
        if(ioctl(fd, SIOCGIFFLAGS, &ifr) == -1) {
                perror("iotcl()");
                return -1;
        }
        ifr.ifr_flags &= ~IFF_PROMISC;
        if(ioctl(fd, SIOCSIFFLAGS, &ifr) == -1) {
                perror("iotcl()");
                return -1;
        }
        return 0;
}

3. socket(AF_INET, SOCK_PACKET, htons(ETH_P_ALL))这个最好不要用,反正我不用...
总结使用方法: 1.只想收到发往本机某种协议的ip数据包的话用第一种就足够了
            2. 更多的详细的内容请使用第二种.包括ETH_P_ALL参数和混杂模式都可以使它的能力不断的加强.
ps:很多自己的想法.虚拟机测试环境.有错欢迎指出交流
qq:110024218
我写的ping

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

#include "unistd.h"
#include "sys/types.h"
#include "sys/socket.h"
#include "netinet/in.h"
#include "netinet/ip.h"
#include "netinet/ip_icmp.h"
#include "netdb.h"
#include "errno.h"
#include "arpa/inet.h"
#include "signal.h"
#include "sys/time.h"

extern int errno;

int sockfd;
struct sockaddr_in addr; //peer addr
char straddr[128]; //peer addr ip(char*)
char sendbuf[2048];
char recvbuf[2048];
int sendnum;
int recvnum;
int datalen = 30;


unsigned short my_cksum(unsigned short *data, int len) {
        int result = 0;
        for(int i=0; i<len/2; i++) {
                result += *data;
                data++;
        }
        while(result >> 16)result = (result&0xffff) + (result>>16);
        return ~result;
}
void tv_sub(struct timeval* recvtime, const struct timeval* sendtime) {
        int sec = recvtime->tv_sec - sendtime->tv_sec;
        int usec = recvtime->tv_usec - sendtime->tv_usec;
        if(usec >= 0) {
                recvtime->tv_sec = sec;
                recvtime->tv_usec = usec;
        } else {
                recvtime->tv_sec = sec-1;
                recvtime->tv_usec = -usec;
        }
}

void send_icmp() {
        struct icmp* icmp = (struct icmp*)sendbuf;
        icmp->icmp_type = ICMP_ECHO;
        icmp->icmp_code = 0;
        icmp->icmp_cksum = 0;
        icmp->icmp_id = getpid(); //needn't use htons() call, because peer networking kernel didn't handle this data and won't make different meanings(bigdian litteldian)
        icmp->icmp_seq = ++sendnum; //needn't use hotns() call too.
        gettimeofday((struct timeval*)icmp->icmp_data, NULL);
        int len = 8+datalen;
        icmp->icmp_cksum = my_cksum((unsigned short*)icmp, len);
        int retval = sendto(sockfd, sendbuf, len, 0, (struct sockaddr*)&addr, sizeof(addr));
        if(retval == -1){
                perror("sendto()");
                exit(-1);
        } else {
// printf("send icmp request to %s(%d) bytes\n", straddr, len);
        }
}
void recv_icmp() {
        struct timeval *sendtime;
        struct timeval recvtime;

        for(;;) {
                int n = recvfrom(sockfd, recvbuf, sizeof(recvbuf), 0, 0, 0);
                if(n == -1) {
                        if(errno == EINTR)continue;
                        else {
                                perror("recvfrom()");
                                exit(-1);
                        }
                } else {
                        gettimeofday(&recvtime, NULL);
                        struct ip *ip = (struct ip*)recvbuf;
                        if(ip->ip_src.s_addr != addr.sin_addr.s_addr) {
// printf("ip_src is not : %s\n", straddr);
                                continue;
                        }
                        struct icmp *icmp = (struct icmp*)(recvbuf + ((ip->ip_hl)<<2));
                        if(icmp->icmp_id != getpid()) {
// printf("icmp_id is not :%d\n", getpid());
                                continue;
                        }
                        recvnum++;
                        sendtime = (struct timeval*)icmp->icmp_data;
                        tv_sub(&recvtime, sendtime);
                        printf("imcp echo from %s(%dbytes)\tttl=%d\tseq=%d\ttime=%d.%06d s\n", straddr, n, ip->ip_ttl, icmp->icmp_seq, recvtime.tv_sec, recvtime.tv_usec);
                }
        }
}
void catch_sigalrm(int signum) {
        send_icmp();
        alarm(1);
}
void catch_sigint(int signum) {
        printf("\nPing statics:send %d packets, recv %d packets, %d%% lost...\n", sendnum, recvnum, (int)((float)(sendnum-recvnum)/sendnum)*100);
        exit(0);
}

int main(int argc, char **argv) {
        if(argc != 2) {
                printf("please use format: ping hostname\n");
                exit(-1);
        }

        sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
        if(sockfd == -1) {
                perror("socket()");
                return -1;
        }

/*
        int sendbufsize = 180;
        socklen_t sendbufsizelen = sizeof(sendbufsize);
        if(setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &sendbufsize, sendbufsizelen) == -1)perror("setsockopt()");
        int recvbufsize;
        socklen_t recvbufsizelen;
        if(getsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &recvbufsize, &recvbufsizelen) == -1)perror("getsockopt()");
*/

        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        int retval = inet_pton(AF_INET, argv[1], &addr.sin_addr);
        if(retval == -1 || retval == 0) {
                struct hostent* host = gethostbyname(argv[1]);
                if(host == NULL) {
                        fprintf(stderr, "gethostbyname(%s):%s\n", argv[1], strerror(errno));
                        exit(-1);
                }
/*
                if(host->h_name != NULL)printf("hostent.h_name:%s\n", host->h_name);
                if(host->h_aliases != NULL && *(host->h_aliases) != NULL)printf("hostent.h_aliases:%s\n", *(host->h_aliases));
                printf("hostent.h_addrtype:%d\n", host->h_addrtype);
                printf("hostent.h_length:%d\n", host->h_length);
*/
                if(host->h_addr_list != NULL && *(host->h_addr_list) != NULL) {
                        strncpy((char*)&addr.sin_addr, *(host->h_addr_list), 4);
                        inet_ntop(AF_INET, *(host->h_addr_list), straddr, sizeof(straddr));
                }
                printf("Ping address:%s(%s)\n\n", host->h_name, straddr);
        } else {
                strcpy(straddr, argv[1]);
                printf("Ping address:%s(%s)\n\n", straddr, straddr);
        }

        struct sigaction sa1;
        memset(&sa1, 0, sizeof(sa1));
        sa1.sa_handler = catch_sigalrm;
        sigemptyset(&sa1.sa_mask);
        sa1.sa_flags = 0;
        if(sigaction(SIGALRM, &sa1, NULL) == -1)perror("sigaction()");
        struct sigaction sa2;
        memset(&sa2, 0, sizeof(sa2));
        sa2.sa_handler = catch_sigint;
        sigemptyset(&sa2.sa_mask);
        sa2.sa_flags = 0;
        if(sigaction(SIGINT, &sa2, NULL) == -1)perror("sigaction()");

        alarm(1);
        recv_icmp();

        return 0;
}

linux原始套接字raw获取ip包,Linux网络编程：原始套接字 SOCK_RAW, IPV6 rawsocket
weixin_39576127的博客
05-05 668
比较新的内核才支持socket(fd, SOCK_RAW, IPPROTO_UDP); // 指定 TCP/UDP/ICMPint val = 1;ret = setsockopt(test->state.sockfd, IPPROTO_IPV6, IPV6_HDRINCL, &val, sizeof(val)); // 比较新的内核才支持remote.sin6_port = 0; ...
Linux 网络编程——原始套接字SOCK_RAW
Hamlee67的博客
10-22 2046
通常情况下程序员接所接触到的套接字（Socket）为两类： （1）流式套接字（SOCK_STREAM）：一种面向连接的 Socket，针对于面向连接的TCP 服务应用； （2）数据报式套接字（SOCK_DGRAM）：一种无连接的 Socket，对应于无连接的 UDP 服务应用。 从用户的角度来看，SOCK_STREAM、SOCK_DGRAM 这两类套接字似乎的确涵盖了 TCP/IP 应用的全部，...
linux sock_raw原始套接字编程 （转！精！）
zhb123168的专栏
04-13 2109
<br />sock_raw原始套接字编程可以接收到本机网卡上的数据帧或者数据包,对与监听网络的流量和分析是很有作用的.一共可以有3种方式创建这种 socket 1.socket(AF_INET, SOCK_RAW, IPPROTO_TCP|IPPROTO_UDP|IPPROTO_ICMP)发送接收ip数据包 2.socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP|ETH_P_ARP|ETH_P_ALL))发送接收以太网数据帧 3.socket(AF_INET, SO
原始套接字SOCK_RAW
qq_18287147的博客
06-04 1089
实际上，我们常用的网络编程都是在应用层的报文的收发操作，也就是大多数程序员接触到的流式套接字(SOCK_STREAM)和数据包式套接字(SOCK_DGRAM)。而这些数据包都是由系统提供的协议栈实现，用户只需要填充应用层报文即可，由系统完成底层报文头的填充并发送。然而在某些情况下需要执行更底层的操作，比如修改报文头、避开系统协议栈等。这个时候就需要使用其他的方式来实现。 一原始套接字 原始套接字(SOCK_RAW)是一种不同于SOCK_STREAM、SOCK_DGRAM的套接字，它实现于系统核心..
Linux网络编程：原始套接字 SOCK_RAW, IPV6 rawsocket
dolphin98629的专栏
06-04 2181
https://stackoverflow.com/questions/31419727/how-to-send-modified-ipv6-packet-through-raw-socket 比较新的内核才支持 1 2 3 4 5 6 7 socket(fd, SOCK_RAW, IPPROTO_UDP); // 指定 TCP/UDP/ICMP int val = 1; ret = setsockopt(test->state.sockfd, IPPROTO
linux sock_raw原始套接字
盘古大叔
09-10 682
原文链接：http://www.cnblogs.com/yoleung/articles/1348250.html sock_raw原始套接字编程可以接收到本机网卡上的数据帧或者数据包,对与监听网络的流量和分析是很有作用的.一共可以有3种方式创建这种socket   1.socket(AF_INET, SOCK_RAW, IPPROTO_TCP|IPPROTO_UDP
linux_sock_raw.rar_RAW_linux sock raw_原始套接字
09-20
本资料“linux_sock_raw.rar”详细介绍了如何在Linux系统中使用原始套接字进行编程，以实现更底层的网络通信功能。 一、原始套接字的概念 原始套接字是一种特殊类型的网络套接字，它允许用户绕过操作系统对网络...
linuxsock_raw原始套接字编程.pdf
11-05
Linux中的sock_raw原始套接字编程是网络编程中一种高级技术，主要用于获取网络接口层的原始数据包，包括IP、ARP、ICMP等协议的数据。它允许程序员绕过操作系统网络堆栈的部分处理，直接访问底层的数据包，这对于网络...
Linux sock_raw原始套接字编程实战与原理解析
Linux sock_raw原始套接字编程是一种高级技术，它允许开发者直接操作网络数据包，包括IP数据包、以太网数据帧等，从而对网络流量进行监控和分析。这种编程接口在网络安全审计、网络设备驱动开发以及底层网络编程中...
Linux sock_raw原始套接字编程详解：捕获网络流量的关键技术
Linux_sock_raw原始套接字编程是一种高级网络接口，它允许应用程序直接访问底层网络协议栈，包括IP、UDP、ICMP等，从而获取或发送原始数据包。这种编程方式对于网络监控、流量分析以及网络设备驱动等领域具有重要...
linux长时间运行任务中断报警trap
djl的专栏，blog.djl.cx好记
11-08 280
每天要运行的定时任务, 时间很长, 有一天突然被中断了, 如果能有个中断提醒就好了。sleep 命令模拟一个长时间运行的任务，并在后台运行它。wait 命令等待任务完成或被杀死，并检查。wait 命令的退出状态码来判断脚本是否被。在这个脚本中，我们使用。
linux rocky 9.4部署和管理docker harbor私有源
xikui1551的博客
11-08 1117
rocky 部署Harbor私有镜像仓库
linux-find和zgrep
luxideyao的专栏
11-07 325
命令本身并不支持递归搜索，它只能搜索单个压缩文件。但是，你可以结合使用。如果你想要搜索所有类型的压缩文件，你可以使用。是你想要搜索的目录的路径。是你想要搜索的文本模式，文件，你可能需要使用。文件并搜索其中的内容。作为输入文件的占位符。
Xshell，Shell的相关介绍与Linux中的权限问题
2301_81265915的博客
11-09 617
首先，先介绍一下我们学习Linux的工具：XshellXShell 是一个流行的 Windows 平台上的 SSH、Telnet 和 Rlogin 客户端，主要用于远程连接 Linux/Unix 系统。它的运行原理大致如下：1：协议支持： XShell 支持多种远程协议（如 SSH、Telnet、Rlogin 等）。最常用的是 SSH 协议，它提供了安全的加密通信。SSH（Secure Shell）通过加密对客户端和服务器之间的通信进行保护，以防止数据在网络中被窃听和篡改。2：建立连接。
SimpleScreenRecorder, a screen recording tool for Linux
最新发布
likecayon的博客
11-11 194
【代码】SimpleScreenRecorder, a screen recording tool for Linux。
LInux基础 （一）：Linux 系统重要命令拾遗
vortex5的博客
11-06 1120
SUID（Set User ID）是文件权限中的一种特殊标志，表示该文件在执行时将使用文件所有者的权限，而不是执行者的权限。Sticky 位是另一种特殊权限，主要用于目录，表示只有文件的所有者才能删除该目录中的文件，而其他用户只能修改自己的文件。硬链接是指向文件的多个入口，所有硬链接指向相同的数据块，不会占用额外的磁盘空间，除非删除所有硬链接。软链接类似于Windows的快捷方式，它是一个独立的文件，包含了指向目标文件的路径。笔记内容参考了B站UP主 泷羽sec 的学习视频，如有侵权，将立即删除。
Linux（CentOS）安装 MySQL
BillKu的博客
11-06 434
MySQL版本：MySQL Community Server 8.4.3 LTS。CentOS版本：CentOS 7。
Linux系列-进程的属性
in_seattle的博客
11-06 952
我们可以看到，这两个死循环同时再跑->两个执行流同时在跑，if 和else if同时成立，从fork之后就会有两个进程，分布进行，fork有两个返回值，给父进程返回子进程的pid，给子进程返回0.这两个分支之间也是父子关系，一个是父进程（自己），一个子进程（fork创建的），一个父进程是可以创建出多个子进程的，所以进程其实也是树形结构。在命令行当中，执行命令，执行程序，本质就是bash的进程，创建的子进程，执行我们的代码，如果是我们刚才创建的进程，这个时候，他的PID是17293，当我们重新启动这个进程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值