raw socket

最新推荐文章于 2023-10-07 22:47:51 发布
最新推荐文章于 2023-10-07 22:47:51 发布
阅读量626 收藏 1
点赞数

1.原始套接字(raw socket)

   1.1 原始套接字工作原理与规则
         原始套接字是一个特殊的套接字类型,它的创建方式跟TCP/UDP创建方法几乎是
一摸一样,例如,通过
  1.        int sockfd;
  2.        sockfd = socktet(AF_INET， SOCK_RAW， IPPROTO_ICMP);
复制代码

这两句程序你就可以创建一个原始套接字.然而这种类型套接字的功能却与TCP或者UDP类型套接字的功能有很大的不同:TCP/UDP类型的套接字只能够访问传输层以及传输层以上的数据,因为当IP层把数据传递给传输层时,下层的数据包头已经被丢掉了.而原始套接字却可以访问传输层以下的数据,,所以使用raw套接字你可以实现上至应用层的数据操作,也可以实现下至链路层的数据操作.
         比如:通过
  1. sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP))
复制代码

方式创建的raw socket就能直接读取链路层的数据.

1)使用原始套接字时应该注意的问题 (参考<<unix网络编程>>以及网上的优秀文档)

(1):对于UDP/TCP产生的IP数据包,内核不将它传递给任何原始套接字,而只是将这些数据交给对应的UDP/TCP数据处理句柄(所以,如果你想要通过原始套接字来访问TCP/UDP或者其它类型的数据,调用socket函数创建原始套接字第三个参数应该指定为htons(ETH_P_IP),也就是通过直接访问数据链路层来实现.(我们后面的密码窃取器就是基于这种类型的).

(2):对于ICMP和EGP等使用IP数据包承载数据但又在传输层之下的协议类型的IP数据包,内核不管是否已经有注册了的句柄来处理这些数据,都会将这些IP数据包复制一份传递给协议类型匹配的原始套接字.

(3):对于不能识别协议类型的数据包,内核进行必要的校验,然后会查看是否有类型匹配的原始套接字负责处理这些数据,如果有的话,就会将这些IP数据包复制一份传递给匹配的原始套接字,否则,内核将会丢弃这个IP数据包,并返回一个ICMP主机不可达的消息给源主机.

(4): 如果原始套接字bind绑定了一个地址,核心只将目的地址为本机IP地址的数包传递给原始套接字,如果某个原始套接字没有bind地址,核心就会把收到的所有IP数据包发给这个原始套接字.

(5): 如果原始套接字调用了connect函数,则核心只将源地址为connect连接的IP地址的IP数据包传递给这个原始套接字.

(6):如果原始套接字没有调用bind和connect函数,则核心会将所有协议匹配的IP数据包传递给这个原始套接字.

2). 编程选项
     原始套接字是直接使用IP协议的非面向连接的套接字,在这个套接字上可以调用bind和connect函数进行地址绑定.说明如下:

(1)bind函数:调用bind函数后,发送数据包的源IP地址将是bind函数指定的地址。如是不调用bind，则内核将以发送接口的主IP地址填充IP头. 如果使用setsockopt设置了IP_HDRINCL(header including)选项,就必须手工填充每个要发送的数据包的源IP地址,否则,内核将自动创建IP首部.

(2)connetc函数:调用connect函数后,就可以使用write和send函数来发送数据包,而且内核将会用这个绑定的地址填充IP数据包的目的IP地址,否则的话,则应使用sendto或sendmsg函数来发送数据包,并且要在函数参数中指定对方的IP地址。

    综合以上种种功能和特点,我们可以使用原始套接字来实现很多功能,比如最基本的数据包分析,主机嗅探等.其实也可以使用原始套接字作一个自定义的传输层协议.

1.2一个简单的应用

    下面的代码创建一个直接读取链路层数据包的原始套接字,并从中分析出源MAC地址和目的MAC地址,源IP和目的IP,以及对应的传输层协议,如果是TCP/UDP协议的话,打印其目的和源端口.为了方便阅读,程序中避免了使用任何与协议有关的数据结构,如
struct ether_header ,struct iphdr  等,当然, 要完全理解代码,你需要关于指针以及位运算的知识
  1. /***************SimpelSniffer.c*************/
  2. //auther:duanjigang@2006s
  3. #include <stdio.h>
  4. #include <unistd.h>
  5. #include <sys/socket.h>
  6. #include <sys/types.h>
  7. #include <linux/if_ether.h>
  8. #include <linux/in.h>
  9. #define BUFFER_MAX 2048

  11. int main(int argc, char *argv[])
  12. {
  13.         
  14.         int sock, n_read, proto;        
  15.         char buffer[BUFFER_MAX];
  16.         char  *ethhead, *iphead, *tcphead, 
  17.                          *udphead, *icmphead, *p;
  18.         
  19. if((sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP))) < 0)
  20.     {
  21.         fprintf(stdout, "create socket error\n");
  22.         exit(0);
  23.     }
  24.         
  25. while(1) 
  26. {
  27.      n_read = recvfrom(sock, buffer, 2048, 0, NULL, NULL);
  28.         /*
  29.         14   6(dest)+6(source)+2(type or length)
  30.         +
  31.         20   ip header 
  32.         +
  33.         8   icmp,tcp or udp header
  34.         = 42
  35.         */
  36. if(n_read < 42) 
  37.    {
  38.       fprintf(stdout, "Incomplete header, packet corrupt\n");
  39.       continue;
  40.    }
  41.                 
  42.         ethhead = buffer;
  43.         p = ethhead;
  44.         int n = 0XFF;
  45.                 printf("MAC: %.2X:%02X:%02X:%02X:%02X:%02X==>"
  46.                            "%.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n",
  47.         p[6]&n, p[7]&n, p[8]&n, p[9]&n, p[10]&n, p[11]&n,
  48.         p[0]&n, p[1]&n, p[2]&n,p[3]&n, p[4]&n, p[5]&n);

  50.                    iphead = ethhead + 14;  
  51.                    p = iphead + 12;
  52.         
  53.            printf("IP: %d.%d.%d.%d => %d.%d.%d.%d\n",
  54.            p[0]&0XFF, p[1]&0XFF, p[2]&0XFF, p[3]&0XFF,
  55.            p[4]&0XFF, p[5]&0XFF, p[6]&0XFF, p[7]&0XFF);
  56.             proto = (iphead + 9)[0];
  57.             p = iphead + 20;
  58.              printf("Protocol: ");
  59.             switch(proto)
  60.               {
  61.                 case IPPROTO_ICMP: printf("ICMP\n");break;
  62.                 case IPPROTO_IGMP: printf("IGMP\n");break;
  63.                 case IPPROTO_IPIP: printf("IPIP\n");break;
  64.                 case IPPROTO_TCP :
  65.                 case IPPROTO_UDP : 
  66.     printf("%s,", proto == IPPROTO_TCP ? "TCP": "UDP"); 
  67.     printf("source port: %u,",(p[0]<<8)&0XFF00 |  p[1]&0XFF);
  68.     printf("dest port: %u\n", (p[2]<<8)&0XFF00 | p[3]&0XFF);
  69.          break;
  70.     case IPPROTO_RAW : printf("RAW\n");break;
  71.     default:printf("Unkown, please query in include/linux/in.h\n");
  72.         }
  73.    }
  74. }
复制代码

这里介绍Windows   Sockets的一些关于原始套接字(Raw   Socket)的编程。同Winsock1相比，最明显的就是支持了Raw   Socket套接字类型，通过原始套接字，我们可以更加自如地控制Windows下的多种协议，而且能够对网络底层的传输机制进行控制。   

1、创建一个原始套接字，并设置IP头选项。   

SOCKET   sock;   
sock   =   socket(AF_INET,SOCK_RAW,IPPROTO_IP);   
或者：   
s   =   WSASoccket(AF_INET,SOCK_RAW,IPPROTO_IP,NULL,0,WSA_FLAG_OVERLAPPED);   

    这里，我们设置了SOCK_RAW标志，表示我们声明的是一个原始套接字类型。创建原始套接字后，IP头就会包含在接收的数据中，如果我们设定   IP_HDRINCL   选项，那么，就需要自己来构造IP头。注意，如果设置IP_HDRINCL   选项，那么必须具有   administrator权限，要不就必须修改注册表：   
HKEY_LOCAL_MACHINE/System/CurrentControlSet/Services/Afd/Parameter/   
修改键：DisableRawSecurity（类型为DWORD），把值修改为   1。如果没有，就添加。   

BOOL   blnFlag=TRUE;   
setsockopt(sock,   IPPROTO_IP,   IP_HDRINCL,   (char   *)&blnFlag,   sizeof(blnFlag);   

    对于原始套接字在接收数据报的时候，要注意这么几点：   
1、如果接收的数据报中协议类型和定义的原始套接字匹配，那么，接收的所有数据就拷贝到套接字中。   
2、如果绑定了本地地址，那么只有接收数据IP头中对应的远端地址匹配，接收的数据就拷贝到套接字中。   
3、如果定义的是外部地址，比如使用connect()，那么，只有接收数据IP头中对应的源地址匹配，接收的数据就拷贝到套接字中。   


2、构造IP头和TCP头   

这里，提供IP头和TCP头的结构：   
//   Standard   TCP   flags   
#define   URG   0x20   
#define   ACK   0x10   
#define   PSH   0x08   
#define   RST   0x04   
#define   SYN   0x02   
#define   FIN   0x01   
typedef   struct   _iphdr   //定义IP首部   
{   
unsigned   char   h_lenver;   //4位首部长度+4位IP版本号   
unsigned   char   tos;   //8位服务类型TOS   
unsigned   short   total_len;   //16位总长度（字节）   
unsigned   short   ident;   //16位标识   
unsigned   short   frag_and_flags;   //3位标志位   
unsigned   char   ttl;   //8位生存时间   TTL   
unsigned   char   proto;   //8位协议   (TCP,   UDP   或其他)   
unsigned   short   checksum;   //16位IP首部校验和   
unsigned   int   sourceIP;   //32位源IP地址   
unsigned   int   destIP;   //32位目的IP地址   
}IP_HEADER;   

typedef   struct   psd_hdr   //定义TCP伪首部   
{   
unsigned   long   saddr;   //源地址   
unsigned   long   daddr;   //目的地址   
char   mbz;   
char   ptcl;   //协议类型   
unsigned   short   tcpl;   //TCP长度   
}PSD_HEADER;   

typedef   struct   _tcphdr   //定义TCP首部   
{   
USHORT   th_sport;   //16位源端口   
USHORT   th_dport;   //16位目的端口   
unsigned   int   th_seq;   //32位序列号   
unsigned   int   th_ack;   //32位确认号   
unsigned   char   th_lenres;       //4位首部长度/6位保留字   
unsigned   char   th_flag;   //6位标志位   
USHORT   th_win;   //16位窗口大小   
USHORT   th_sum;   //16位校验和   
USHORT   th_urp;   //16位紧急数据偏移量   
}TCP_HEADER;   

TCP伪首部并不是真正存在的，只是用于计算检验和。校验和函数：   

USHORT   checksum(USHORT   *buffer,   int   size)   
{   
    unsigned   long   cksum=0;   
    while   (size   >   1)   
    {   
        cksum   +=   *buffer++;   
        size   -=   sizeof(USHORT);       
    }   
    if   (size)   
    {   
        cksum   +=   *(UCHAR*)buffer;       
    }   
    cksum   =   (cksum   > >   16)   +   (cksum   &   0xffff);   
    cksum   +=   (cksum   > > 16);   
    return   (USHORT)(~cksum);   
}   

    当需要自己填充IP头部和TCP头部的时候，就同时需要自己计算他们的检验和。   

3、发送原始套接字数据报   

    填充这些头部稍微麻烦点，发送就相对简单多了。只需要使用sendto()就OK。   

sendto(sock,   (char*)&tcpHeader,   sizeof(tcpHeader),   0,   (sockaddr*)&addr_in,sizeof(addr_in));  

 

4、接收数据   
    和发送原始套接字数据相比，接收就比较麻烦了。因为在WIN我们不能用recv()来接收raw   socket上的数据，这是因为，所有的IP包都是先递交给系统核心，然后再传输到用户程序，当发送一个raws   socket包的时候（比如syn），核心并不知道，也没有这个数据被发送或者连接建立的记录，因此，当远端主机回应的时候，系统核心就把这些包都全部丢掉，从而到不了应用程序上。所以，就不能简单地使用接收函数来接收这些数据报。   

    要达到接收数据的目的，就必须采用嗅探，接收所有通过的数据包，然后进行筛选，留下符合我们需要的。可以再定义一个原始套接字，用来完成接收数据的任务，需要设置SIO_RCVALL，表示接收所有的数据。   

SOCKET   sniffersock;   
sniffsock   =   WSASocket(AF_INET,   SOCK_RAW,   IPPROTO_IP,   NULL,   0,   WSA_FLAG_OVERLAPPED);   

DWORD   lpvBuffer   =   1;   
DWORD   lpcbBytesReturned   =   0   ;   
WSAIoctl(sniffersock,   SIO_RCVALL,   &lpvBuffer,   sizeof(lpvBuffer),   NULL,   0,   &   lpcbBytesReturned,   NULL,   NULL);   

    创建一个用于接收数据的原始套接字，我们可以用接收函数来接收数据包了。然后在使用一个过滤函数达到筛选的目的，接收我们需要的数据包。  

 

下面是一个示例程序，可以作为SYN扫描的一部分。   

#include   <stdio.h>   
#include   <winsock2.h>   
#include   <ws2tcpip.h>   

#define   SOURCE_PORT   7234   
#define   MAX_RECEIVEBYTE   255   

typedef   struct   ip_hdr   //定义IP首部   
{   
unsigned   char   h_verlen;   //4位首部长度,4位IP版本号   
unsigned   char   tos;   //8位服务类型TOS   
unsigned   short   total_len;   //16位总长度（字节）   
unsigned   short   ident;   //16位标识   
unsigned   short   frag_and_flags;   //3位标志位   
unsigned   char   ttl;   //8位生存时间   TTL   
unsigned   char   proto;   //8位协议   (TCP,   UDP   或其他)   
unsigned   short   checksum;   //16位IP首部校验和   
unsigned   int   sourceIP;   //32位源IP地址   
unsigned   int   destIP;   //32位目的IP地址   
}IPHEADER;   

typedef   struct   tsd_hdr   //定义TCP伪首部   
{   
unsigned   long   saddr;   //源地址   
unsigned   long   daddr;   //目的地址   
char   mbz;   
char   ptcl;   //协议类型   
unsigned   short   tcpl;   //TCP长度   
}PSDHEADER;   

typedef   struct   tcp_hdr   //定义TCP首部   
{   
USHORT   th_sport;   //16位源端口   
USHORT   th_dport;   //16位目的端口   
unsigned   int   th_seq;   //32位序列号   
unsigned   int   th_ack;   //32位确认号   
unsigned   char   th_lenres;   //4位首部长度/6位保留字   
unsigned   char   th_flag;   //6位标志位   
USHORT   th_win;   //16位窗口大小   
USHORT   th_sum;   //16位校验和   
USHORT   th_urp;   //16位紧急数据偏移量   
}TCPHEADER;   

//CheckSum:计算校验和的子函数   
USHORT   checksum(USHORT   *buffer,   int   size)   
{   
unsigned   long   cksum=0;   
while(size   > 1)   
{   
cksum+=*buffer++;   
size   -=sizeof(USHORT);   
}   
if(size   )   
{   
cksum   +=   *(UCHAR*)buffer;   
}   

cksum   =   (cksum   > >   16)   +   (cksum   &   0xffff);   
cksum   +=   (cksum   > > 16);   
return   (USHORT)(~cksum);   
}   

void   useage()   
{   
printf( "******************************************/n ");   
printf( "TCPPing/n ");   
printf( "/t   Written   by   Refdom/n ");   
printf( "/t   Email:   refdom@263.net/n ");   
printf( "Useage:   TCPPing.exe   Target_ip   Target_port   /n ");   
printf( "*******************************************/n ");   
}   

int   main(int   argc,   char*   argv[])   
{   
WSADATA   WSAData;   
SOCKET   sock;   
SOCKADDR_IN   addr_in;   
IPHEADER   ipHeader;   
TCPHEADER   tcpHeader;   
PSDHEADER   psdHeader;   

char   szSendBuf[60]={0};   
BOOL   flag;   
int   rect,nTimeOver;   

useage();   

if   (argc!=   3)   
{   return   false;   }   

if   (WSAStartup(MAKEWORD(2,2),   &WSAData)!=0)   
{   
printf( "WSAStartup   Error!/n ");   
return   false;   
}   

if   ((sock=WSASocket(AF_INET,SOCK_RAW,IPPROTO_RAW,NULL,0,WSA_FLAG_OVERLAPPED))==INVALID_SOCKET)   
{   
printf( "Socket   Setup   Error!/n ");   
return   false;   
}   
flag=true;   
if   (setsockopt(sock,IPPROTO_IP,   IP_HDRINCL,(char   *)&flag,sizeof(flag))==SOCKET_ERROR)   
{   
printf( "setsockopt   IP_HDRINCL   error!/n ");   
return   false;   
}   

nTimeOver=1000;   
if   (setsockopt(sock,   SOL_SOCKET,   SO_SNDTIMEO,   (char*)&nTimeOver,   sizeof(nTimeOver))==SOCKET_ERROR)   
{   
printf( "setsockopt   SO_SNDTIMEO   error!/n ");   
return   false;   
}   
addr_in.sin_family=AF_INET;   
addr_in.sin_port=htons(atoi(argv[2]));   
addr_in.sin_addr.S_un.S_addr=inet_addr(argv[1]);   

//   
//   
//填充IP首部   
ipHeader.h_verlen=(4 < <4   |   sizeof(ipHeader)/sizeof(unsigned   long));   
//   ipHeader.tos=0;   
ipHeader.total_len=htons(sizeof(ipHeader)+sizeof(tcpHeader));   
ipHeader.ident=1;   
ipHeader.frag_and_flags=0;   
ipHeader.ttl=128;   
ipHeader.proto=IPPROTO_TCP;   
ipHeader.checksum=0;   
ipHeader.sourceIP=inet_addr( "本地地址 ");   
ipHeader.destIP=inet_addr(argv[1]);   

//填充TCP首部   
tcpHeader.th_dport=htons(atoi(argv[2]));   
tcpHeader.th_sport=htons(SOURCE_PORT);   //源端口号   
tcpHeader.th_seq=htonl(0x12345678);   
tcpHeader.th_ack=0;   
tcpHeader.th_lenres=(sizeof(tcpHeader)/4 < <4|0);   
tcpHeader.th_flag=2;   //修改这里来实现不同的标志位探测，2是SYN，1是FIN，16是ACK探测   等等   
tcpHeader.th_win=htons(512);   
tcpHeader.th_urp=0;   
tcpHeader.th_sum=0;   

psdHeader.saddr=ipHeader.sourceIP;   
psdHeader.daddr=ipHeader.destIP;   
psdHeader.mbz=0;   
psdHeader.ptcl=IPPROTO_TCP;   
psdHeader.tcpl=htons(sizeof(tcpHeader));   

//计算校验和   
memcpy(szSendBuf,   &psdHeader,   sizeof(psdHeader));   
memcpy(szSendBuf+sizeof(psdHeader),   &tcpHeader,   sizeof(tcpHeader));   
tcpHeader.th_sum=checksum((USHORT   *)szSendBuf,sizeof(psdHeader)+sizeof(tcpHeader));   

memcpy(szSendBuf,   &ipHeader,   sizeof(ipHeader));   
memcpy(szSendBuf+sizeof(ipHeader),   &tcpHeader,   sizeof(tcpHeader));   
memset(szSendBuf+sizeof(ipHeader)+sizeof(tcpHeader),   0,   4);   
ipHeader.checksum=checksum((USHORT   *)szSendBuf,   sizeof(ipHeader)+sizeof(tcpHeader));   

memcpy(szSendBuf,   &ipHeader,   sizeof(ipHeader));   

rect=sendto(sock,   szSendBuf,   sizeof(ipHeader)+sizeof(tcpHeader),   
0,   (struct   sockaddr*)&addr_in,   sizeof(addr_in));   
if   (rect==SOCKET_ERROR)   
{   
printf( "send   error!:%d/n ",WSAGetLastError());   
return   false;   
}   
else   
printf( "send   ok!/n ");   

closesocket(sock);   
WSACleanup();   

return   0;   
}  

xiaolei1982
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RawSocket在链路层的收发，arp，多线程指定网守发示例
07-14
RawSocket在链路层的收发，arp，多线程指定网守发示例
raw socket编程例子
husterfisher的专栏
06-04 1387
前几天看了看>第一卷,为了加深理解,便写了几个简单的程序,最近好忙,但是又怕忘记前面所学的知识,就粗糙的整理了一下,贴出来,希望能给初学者以指导,同时借助CU的论坛做个备份,呵呵. 内容安排: 1.原始套接字介绍   1.1 原始套接字工作原理与规则   1.2 简单应用 2 FTP密码窃取器实现(简单的rootkit)   2.1 设计思路   2.2 实现   2.3 不足与改
Linux小知识--原始套接字（raw socket）之模拟ping
小人物的编程
11-04 4157
利用原始套接字模拟ping
Linux网络编程- 原始套接字（Raw Socket）
最新发布
青衫客36的博客
10-07 3973
原始套接字（Raw Socket）提供了一种机制，允许应用程序直接访问底层传输协议，绕过操作系统提供的传输层接口。这种套接字通常用于实现新的协议或对现有协议进行低级别的操作。以下是对原始套接字的详细介绍：定义与用途:创建:特权:工作方式:用途与限制:注意事项:跨平台的差异:总的来说，原始套接字是一个非常强大的工具，但也需要谨慎使用。正确使用它需要对网络协议有深入的理解，而滥用它可能导致网络问题或被视为恶意活动。创建链路层的原始套接字允许我们直接与链路层设备（例如以太网适配器）交互，从而可以发送和接收链路层帧
网络编程知识
上官宏竹的专栏
09-15 1879
就是说对方处于LAST_ ACK 状态下的SOCKET可能会因为超时未收到ACK报文，而重发FIN报文，所以这个。
raw socket demo
06-03
在压缩包文件名称列表中，"rawsocket"可能是源代码文件或相关资源文件的名称。实际操作时，可以解压该文件，查看源代码以了解如何在具体编程语言中实现raw socket的功能。 总结，raw sockets提供了一种直接与网络...
rawsocket抓包侦听
10-10
**rawsocket抓包侦听**是一种网络数据包捕获技术，它通过使用操作系统底层的原始套接字（raw sockets）来直接访问网络层的数据包，而不是通过应用层协议（如TCP或UDP）进行通信。这种方法使得开发者可以直接查看和...
利用rawsocket实现本机网络报文监控解析
11-06
例如，`RawSocketTest.cpp`和`RawSocket_Test.cpp`可能包含测试Raw Socket功能的代码，而`PacketStruct.h`可能定义了用于存储和解析报文结构的类或结构体。`NetCapture`系列的文件可能是项目工程文件，用于编译和...
raw socket是啥(一)？
Pou光明的博客
08-14 709
对于网络通讯，耳熟能详的莫过于TCP、UDP，二者皆需要ip和port。对于一般开发人员，找到一个“能用”的库就可以了，因为流式通讯，会有粘包问题，那就需要再加一个库，解决粘包问题，这样一个基本的通讯框架就OK了。很多情况下，我们并没有了解网络通讯内部的结构，对于网络7层模型也是一知半解，这些都很值得探索。考虑一种情况：当我们的linux上位机需要和嵌入式设备进行网络通讯，选择哪种网络协议比较好呢...
RAW socket
zion--6135的博客
10-19 2313
当网卡处于这种“混杂”模式时，它对所有遇到的每一个数据帧都产生一个硬件中断，以提醒操作系统处理流经该物理媒体上的每一个报文包。要注意的是send/recv函数使用MSG_WAITALL的时候，sockfd 必须是处于阻塞模式下，否则WAITALL不能起作用。socket(PF_PACKET, SOCK_RAW, htons(ETH_P_XXX)) // 发送、接收数据链路层。查资料发现：默认情况下，网卡接收一个包，网卡只把发给本机的包（包括广播包）传到上层的APP。【以ptp报文帧为例】
RAW socket使用
kking_edc的博客
06-09 3200
一、通用 首先讨论在使用以下任何API进行开发时必须考虑的一些一般性问题。除了这里引出的问题外，编程者还必须注意他想要使用的网络协议的特殊性。如果没有注意到这种特殊性，例如交换信息的正确顺序，就不能确保我们能够与另一个主机通信。 1.1 字节顺序 在网络通信中，字节顺序（也称为endianness）对于正确设置和解释字段至关重要。每当一个值需要超过1字节的存储空间时，我们就必须在网络字节顺序和主机字节顺序之间进行转换。根据所使用的协议和操作系统，网络字节顺序和主机字节顺序可能不同。对于IP协议，网络字节顺序
raw socket应用笔记
OnlyLove_的博客
03-14 800
AF_INET：能看到网络层数据。AF_PACKET：能看到链路层数据。AF_INET + SOCK_STREAM：获取基于TCP协议的应用层数据（不能获取TCP头部信息）。AF_INET + SOCK_DGRAM：获取基于UDP协议的应用层数据（不能获取UDP头部信息）。AF_INET + SOCK_RAW：获取基于IP协议的传输层数据（不能获取IP头部信息），获取IP头部信息需要开启IP_HDRINCL特性。
Raw Socket 接收和发送数据包
maimang1001的专栏
02-11 1万+
snippet/raw-socket.md at master · xgfone/snippet · GitHubhttps://github.com/xgfone/snippet/blob/master/snippet/docs/linux/program/raw-socket.md Raw Socket 接收和发送数据包 前言 对于网络层IP数据包的接收、发送，RAW SOCKET 接口是通用的，具有可移植性。 但对于数据链路层数据帧的接收、发送，不同的系统有不同的机制，不具有可移植性。 对于
网络编程原始套接字
Try Try Again
03-09 1271
网络编程原始套接字 SOCKET_STREAM 流式套接字     SOCKET_DGRAM       SOCKET_RAW 原始套接字   IPPROTO_IP IP协议   IPPROTO_ICMP INTERNET控制消息协议，配合原始套接字可以实现ping的功能   IPPROTO_IGMP INTERNET 网关服务协议，在多播中
Raw Socket和Socket编程
热门推荐
KZM2008的专栏
03-12 3万+
 1.原始套接字(raw socket)  1.1 原始套接字工作原理与规则         原始套接字是一个特殊的套接字类型,它的创建方式跟TCP/UDP创建方法几乎是一摸一样,例如,通过CODE:[Copy to clipboard]       int sockfd;       sockfd = socktet(AF_INET， SOCK_RAW， IPPROTO_
有关raw socket的一些知识
Information Security Technology Organization
02-21 8161
    众所周知,通过socket编程,我们能够实现机器之间的通信.在TCP/IP协议簇(PF_INET)中,可以建立面向连接的SOCK_STREAM类型的socket,非连接的SOCK_DGRAM类型的socket.事实上,在所有的网络程序中,也是这两种socket用的最为广泛.除此之外,还有一些不常用的socket类型,它们却是在某些网络通信中担当重要的角色.这里要讲的就是这么一种sock
ARP协议及raw socket复现ARP断网攻击
夜栩的博客
05-19 490
主机发送信息时将包含目标IP地址的ARP请求广播到局域网络上的所有主机，并接收返回消息，以此确定目标的物理地址；在网络的数据链路层只能看见 MAC 帧，链路层以上的数据都被封装在 MAC 帧中，MAC 帧包含源 MAC 地址和目的MAC 地址，在实际局域网络中传送数据时，根据 MAC 地址寻找目的主机。虽然例如kali有成熟的工具，python也有强大的scapy网络库，但本次实验主要从底层学习掌握ARP协议的相关知识，使用套接字自定义构造数据包。网关的ARP记录被自动删除，达到修复的目的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值