linux c 原始套接字抓包

最新推荐文章于 2023-03-01 16:17:09 发布
最新推荐文章于 2023-03-01 16:17:09 发布
阅读量493 收藏
点赞数
文章标签： socket linux 虚拟机 c c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_8510/article/details/82513375
版权
抓包分析主机上网浏览了那些网页，并把浏览网页的网址写入一个文件。

首先我列举下我在写抓包程序所犯下的错误。供大家学习参考。

创建原始套接字失败：

分析原因：刚开始的时候运行程序正常，但是同事覃书芹帮我虚拟机添加了一个虚拟网卡的时候就出现错误了。原因说出来很简单，就是设备名称错误，但是当时我怎么调都调不出来。最后请他们看了下，一下就看出来了。起码让我明白创建套接字的时候要与监听的网卡名称相对应，不然要监听eth1,结果在绑定设备名称的时候绑成了eth0，那就可能出现错误，获得不到效果。

1. 写文件总是乱码：

分析原因：这个问题在我进公司前以前就犯过，那时候是用C++写，改正过来比较快。现在在全字符环境下，改了半天，最后发现，在写的时候直接传了地址，而没有加上所传字符串的长度。导致乱码，加上一个sizeof()以后问题解决。

2. 浏览部分网页时程序出现段错误：

在C环境下，出现段错误是很常见的，但对于我来说见的很少，所以出现这类问题的时候显得还不到哪错了。原因是我在定位域名字段的时候是以“com\r\n”结束为标记的。因为很多域名都是以.com结尾的，所以就忽略了还有以“.cn”或者以“.net”结尾的域名。我当时就奇怪了，为什么有的网页可以，但是访问有些域名的时候，一点击就出错。当找不到.com的时候就会定位到下一个包，定义到一个不存在的内存区域。所以导致段错误。

3. 分析的出是tcp包但是分析不出是http包：

错误原因：这个错误本来应该是不会出现的，就是我把usleep(1000),改为了sleep（1），都是停止一秒钟。在while循环里用sleep（1）可以让程序暂停执行一秒钟效果很明显，但是usleep（1000）就不是很明显了。在while循环里用sleep（1）就明显减慢了抓包的速度，所以就出现抓漏了包的情况。把while循环里的sleep（1）改成usleep（1000）；就行了。

程序过程：

首先抓住经过网卡的数据包，首先检测他是不是ip包，如果是剥去包头，然后看是不是tcp包，如果是则检测它的端口是不是80端口。如果是则证明传输的是http协议。然后就可以分析是不是存在“get”字段，是不是存在“host”字段。然后取“host”后面的一个字符串，即我们要得到的主机访问的域名，即上网记录。

具体代码如下： 


#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/ioctl.h>

#include <net/ethernet.h>

#include <netinet/in.h>
#include <linux/if_ether.h>
#include <linux/if_packet.h>
#include <linux/if_arp.h>




#define NOT_UNICAST(e) ((e[0] & 0x01) != 0)


#define APP_NAME "pppc"
#define APP_VER  "0.1.0"

#define PPPOE_DISCOVER  0x8863
#define PPPOE_SESSION   0x8864

#define ETH_ALEN      6
#define NET_FACE_LEN  8

#define TRUE  1
#define FALSE 0

#ifndef ETH_DATA_LEN
#define ETH_DATA_LEN  ETHERMTU
#endif


#pragma pack(1)

typedef struct __st_pconn
{
    unsigned char  myName[NET_FACE_LEN];
    unsigned char  myEth[ETH_ALEN];
    unsigned char  peerEth[ETH_ALEN];

    unsigned short session_id;
    int            net_socket;

} tPconn;

typedef struct __st_eth_head
{
    unsigned char  dst[ETH_ALEN];
    unsigned char  src[ETH_ALEN];
    unsigned short proto;

} tEthHead;

typedef struct __st_pppoe_head
{
    unsigned char  ver:4;
    unsigned char  type:4;
    unsigned char  code;
    unsigned short sid;
    unsigned short len;

} tPPPPOEHead;

typedef struct __st_pppoe_pkt_info
{
    tEthHead      ethHead;
    tPPPPOEHead   pppoeHead;
    unsigned char payload[32];

} tPPPOEPkt;

typedef struct __st_ip_pkt_head
{
   //unsigned char  hlen:4;
   //unsigned char  ver:4;
   unsigned char  vhlen;
   unsigned char  tos;
   unsigned short tlen;
   unsigned short ipid;
   unsigned short flag;
   unsigned char  ttl;
   unsigned char  proto;
   unsigned short checksum;
   unsigned long  sip;
   unsigned long  dip;
   unsigned char  data[1];

} tIPktHead;


typedef struct _st_tcp
{
   unsigned short sport;
   unsigned short dport;
   unsigned long  seq;
   unsigned long  ack;
   unsigned char  offset;
   unsigned char  code;
   unsigned short window;
   unsigned short cksum;
   unsigned short urg;
   unsigned char  data[1];

} tTcp;


#pragma pack()




/// Define public var //
tPconn myConn;
/// End of Define public var ///

char *inet_htoa(unsigned long ipaddr)
{
    static char buf[10][20];
    static int  old_index=0;
    int    index;
    unsigned char  t1;
    unsigned char  bFlag = FALSE;
    char   *pbuf;

    index     = old_index;
    old_index = (old_index+1) % 10;

    pbuf  = buf[index];
    t1    = (ipaddr >> 24) & 0xff;
    *pbuf = (t1 / 100);
    if (*pbuf != 0)
    {
        *pbuf += 0x30;
        pbuf++;
        bFlag = TRUE;
    }
    *pbuf = ((t1 / 10) % 10);
    if (*pbuf != 0)
    {
        *pbuf += 0x30;
        pbuf++;
    }
    else if (bFlag)
    {
        *pbuf += 0x30;
          pbuf++;
    }
    *pbuf++ = (t1 % 10) + 0x30;
    *pbuf++ = '.';

    /******************************/
    bFlag = FALSE;
    t1 = (ipaddr >> 16) & 0xff;
    *pbuf = (t1 / 100);
    if (*pbuf != 0)
    {
        *pbuf += 0x30;
        pbuf++;
        bFlag = TRUE;
    }
    *pbuf = ((t1 / 10) % 10);
    if (*pbuf != 0)
    {
        *pbuf += 0x30;
        pbuf++;
    }
    else if (bFlag)
    {
        *pbuf += 0x30;
        pbuf++;
    }
    *pbuf++ = (t1 % 10) + 0x30;
    *pbuf++ = '.';

    /******************************/
    bFlag = FALSE;
    t1 = (ipaddr >> 8) & 0xff;
    *pbuf = (t1 / 100);
    if (*pbuf != 0)
    {
        *pbuf += 0x30;
        pbuf++;
        bFlag = TRUE;
    }
    *pbuf = ((t1 / 10) % 10);
    if (*pbuf != 0)
    {
        *pbuf += 0x30;
        pbuf++;
    }
    else if (bFlag)
    {
        *pbuf += 0x30;
        pbuf++;
    }
    *pbuf++ = (t1 % 10) + 0x30;
    *pbuf++ = '.';

    /******************************/
    bFlag = FALSE;
    t1 = ipaddr & 0xff;
    *pbuf = (t1 / 100);
    if (*pbuf != 0)
    {
        *pbuf += 0x30;
        pbuf++;
        bFlag = TRUE;
    }
    *pbuf = ((t1 / 10) % 10);
    if (*pbuf != 0)
    {
        *pbuf += 0x30;
        pbuf++;
    }
    else if (bFlag)
    {
        *pbuf += 0x30;
        pbuf++;
    }
    *pbuf++ = (t1 % 10) + 0x30;
    *pbuf = '\0';

    pbuf   = buf[index];
    return pbuf;
}


int init_rawsocket(char *dev_name)
{
    int raw_sock_fd;
    struct sockaddr_ll sll;
    struct ifreq ifstruct;

    memset(&sll, 0, sizeof(struct sockaddr_ll));
    strcpy(ifstruct.ifr_name, dev_name);


    raw_sock_fd = socket(PF_PACKET, SOCK_RAW, htons(IPPROTO_RAW));

    if (ioctl(raw_sock_fd, SIOCGIFINDEX, &ifstruct) == -1)//指定socket，把信息存入到ifstruct中
    {
        printf("ioctl SIOCGIFINDEX [%s] Error!!!", dev_name);
        close(raw_sock_fd);
        exit(1);
        return -1;
    }

    sll.sll_family   = PF_PACKET;
    sll.sll_ifindex  = ifstruct.ifr_ifindex;
    sll.sll_protocol = htons(ETH_P_ALL);
    sll.sll_hatype   = ARPHRD_ETHER;
    sll.sll_pkttype  = PACKET_OTHERHOST;
    sll.sll_halen    = ETH_ALEN;
    sll.sll_addr[6]  = 0;
    sll.sll_addr[7]  = 0;

    if (ioctl(raw_sock_fd, SIOCGIFHWADDR, &ifstruct) == -1)
    {
        printf("\nioctl SIOCGIFHWADDR [%s] Error!!!", dev_name);
        close(raw_sock_fd);
        exit(1);
        return -1;
    }

    if (ioctl(raw_sock_fd, SIOCGIFFLAGS, &ifstruct) < 0)
 {
  printf("ioctl SIOCGIFFLAGS [%s] Error!!!", dev_name);
  close(raw_sock_fd);
                exit(1);
  return -1;
 }
#if 1
    ifstruct.ifr_flags |= IFF_PROMISC;   //set promisc
    if (ioctl(raw_sock_fd, SIOCSIFFLAGS, &ifstruct) == -1)
    {
        printf("Set [%s] promisc error\n", dev_name);
        close(raw_sock_fd);
        exit(1);
        return -1;
    }
#endif
    if (bind(raw_sock_fd, (struct sockaddr *)&sll, sizeof(struct sockaddr_ll)) == -1)
 {
  printf("Bind %s Error!", dev_name);
  close(raw_sock_fd);
              exit(1);
  return -1;
 }

    return raw_sock_fd;


} /* End of init_rawsocket */


int init_netface(tPconn *pPconn)
{
    struct ifreq ifr; 
    struct sockaddr_ll pSock;
    int optval = 1;

    if (!pPconn)   
        return 0;

 //把创建 的socket套接字传给pCONN
    pPconn->net_socket = init_rawsocket(pPconn->myName);
    printf("Raw fd [%d]\n", pPconn->net_socket);

    strncpy(ifr.ifr_name, pPconn->myName, NET_FACE_LEN);  


    //获取网卡的MAC地址
 if (ioctl(pPconn->net_socket, SIOCGIFHWADDR, &ifr) < 0)
 {
     printf("ioctl(SIOCGIFHWADDR) error");
     exit(0);
 }
 memcpy(pPconn->myEth, ifr.ifr_hwaddr.sa_data, ETH_ALEN);


 printf("Get [%s], MAC [%02x:%02x:%02x:%02x:%02x:%02x]\n",
         pPconn->myName, pPconn->myEth[0], pPconn->myEth[1], pPconn->myEth[2],
         pPconn->myEth[3], pPconn->myEth[4], pPconn->myEth[5]);


    return 1;

}




int main(int argc, char **argv)
{
    int raw_fd = 0;
    int rlen   = 0;
    int n      = 0;
    char buff[1500] = {0};
    tEthHead *pEth = NULL;
    tIPktHead*pOeh = NULL;
    tTcp     *ptcp = NULL;
    char     *tcpdata = NULL;
    char     *tcpdend = NULL;
    int      tcpdatalen = 0;
    char     data [1024]={0} ;
    char     *host = NULL;
    char     *hostend = NULL;
    char     hostdata[1024]={0};
    char    ptjay[30];

    memset(&myConn, 0, sizeof(tPconn));

    sprintf(myConn.myName, "eth0");
    init_netface(&myConn); 

    printf("%s (v%s) started\n", APP_NAME, APP_VER);

    printf("Eth head len %d, PPPOE head len %d, PPPOE pkt len %d\n",
            sizeof(tEthHead), sizeof(tPPPPOEHead), sizeof(tPPPOEPkt));


    while (1)
    {
        //send_PADI(&myConn);
        rlen = read(myConn.net_socket, buff, 1514);//读取数据报
        if (rlen > 0)
        {
            pEth = (tEthHead *)buff;  


           // printf("Get a packet, DMAC [%02x:%02x:%02x:%02x:%02x:%02x], SMAC [%02x:%02x:%02x:%02x:%02x:%02x]\n",
           //        pEth->dst[0], pEth->dst[1],pEth->dst[2],pEth->dst[3],pEth->dst[4],pEth->dst[5],
           //         pEth->src[0], pEth->src[1],pEth->src[2],pEth->src[3],pEth->src[4],pEth->src[5]);
            switch (ntohs(pEth->proto))
            {
                case 0x0800:
                {
                    pOeh = (tIPktHead*)(buff+sizeof(tEthHead));
                   // printf("Get a ip packet\n");
                   // printf("SIP[%s], DIP[%s], ipid [%d], tlen [%d], ver [%d], hlen [%d]\n",
                   //       inet_htoa(ntohl(pOeh->sip)), inet_htoa(ntohl(pOeh->dip)),
                   //        ntohs(pOeh->ipid), ntohs(pOeh->tlen), (pOeh->vhlen&0xf0)>>4, (pOeh->vhlen&0x0f)<<2);
                    switch (pOeh->proto)
                    {
                        case 0x06:
                        {
                              //printf("Get a TCP packet\n");

                            ptcp = (tTcp*)pOeh->data; 
       //printf("%d\n",ntohs(ptcp->dport));
                            if (ntohs(ptcp->dport)==80)
                            {
                             //  printf("Get a http packet\n");

                               tcpdata = (char*)(ptcp->data);                              
                               if(strncmp(tcpdata, "GET ", 4) == 0)
                                  {
                                    //printf("Get a get http packet\n");

                                    tcpdend = strstr(ptcp->data, " HTTP/1.1\r\n");

                                    printf("http data is \n");

                                    tcpdata += 4;
                                    tcpdatalen = tcpdend-tcpdata;

                                    printf("%d\n", tcpdatalen);

                                    printf("%s\n", strncpy(data, tcpdata, tcpdatalen));

                                   host = strstr(ptcp->data, "Host: ");
     strncpy(ptjay,host,30);
     printf("测试用的%s\n",ptjay);
                                   hostend = strstr(ptjay, "\r\n");
     strncpy(ptjay,hostend,5);
     printf("测试用的二%s",ptjay);
                                   tcpdatalen = hostend - host;

                                   printf("%s\n",strncpy(hostdata, host, tcpdatalen));
     host=NULL;
     hostend=NULL;
     strncpy(data,"0",1);
     strncpy(ptjay,"0",1);

                                   }
                               //else
                               //   printf("Get other http packet\n");


                             }
                            // else
                            //    printf("Get not http packet\n");

                        }
                        break;

                        default:
                      //  printf("Get not tcp packet\n");
                        break;
                    }
                }
                break;

                default:
                    //printf("Get other packet\n");
                break;
            }              
        }
        //printf("Send PADI\n");
        //printf("包结束\n");
        usleep(1000);
    }



}



int init_rawsocket(char *dev_name)
{
    int raw_sock_fd;
    struct sockaddr_ll sll;
    struct ifreq ifstruct;

    memset(&sll, 0, sizeof(struct sockaddr_ll));
    strcpy(ifstruct.ifr_name, dev_name);

    raw_sock_fd = socket(PF_PACKET, SOCK_RAW, htons(IPPROTO_RAW));
    if (ioctl(raw_sock_fd, SIOCGIFINDEX, &ifstruct) == -1)//指定socket，把信息存入到ifstruct中
    {
        printf("ioctl SIOCGIFINDEX [%s] Error!!!", dev_name);
        close(raw_sock_fd);
        exit(1);
        return -1;
    }

    sll.sll_family   = PF_PACKET;
    sll.sll_ifindex  = ifstruct.ifr_ifindex;
    sll.sll_protocol = htons(ETH_P_ALL);
    sll.sll_hatype   = ARPHRD_ETHER;
    sll.sll_pkttype  = PACKET_OTHERHOST;
    sll.sll_halen    = ETH_ALEN;
    sll.sll_addr[6]  = 0;
    sll.sll_addr[7]  = 0;

    if (ioctl(raw_sock_fd, SIOCGIFHWADDR, &ifstruct) == -1)
    {
        printf("\nioctl SIOCGIFHWADDR [%s] Error!!!", dev_name);
        close(raw_sock_fd);
        exit(1);
        return -1;
    }

    if (ioctl(raw_sock_fd, SIOCGIFFLAGS, &ifstruct) < 0)
    {
        printf("ioctl SIOCGIFFLAGS [%s] Error!!!", dev_name);
        close(raw_sock_fd);
                exit(1);
        return -1;
    }
#if 1
    ifstruct.ifr_flags |= IFF_PROMISC;   //set promisc
    if (ioctl(raw_sock_fd, SIOCSIFFLAGS, &ifstruct) == -1)
    {
        printf("Set [%s] promisc error\n", dev_name);
        close(raw_sock_fd);
        exit(1);
        return -1;
    }
#endif
    if (bind(raw_sock_fd, (struct sockaddr *)&sll, sizeof(struct sockaddr_ll)) == -1)
    {
        printf("Bind %s Error!", dev_name);
        close(raw_sock_fd);
              exit(1);
        return -1;
    }

    return raw_sock_fd;
} /* End of init_rawsocket */


int init_netface(tPconn *pPconn)
{
    struct ifreq ifr;  
    struct sockaddr_ll pSock;
    int optval = 1;

    if (!pPconn)    
        return 0;

    //把创建 的socket套接字传给pCONN
    pPconn->net_socket = init_rawsocket(pPconn->myName);
    printf("Raw fd [%d]\n", pPconn->net_socket);

    strncpy(ifr.ifr_name, pPconn->myName, NET_FACE_LEN);   


    //获取网卡的MAC地址
    if (ioctl(pPconn->net_socket, SIOCGIFHWADDR, &ifr) < 0) 
    {
        printf("ioctl(SIOCGIFHWADDR) error");
        exit(0);
    }
    memcpy(pPconn->myEth, ifr.ifr_hwaddr.sa_data, ETH_ALEN);

    printf("Set mac?");
    if(getchar()=='y')
    {
	printf("mac:");
	scanf("%02x%02x%02x%02x%02x%02x",&pPconn->myEth[0], &pPconn->myEth[1], &pPconn->myEth[2], 
              &pPconn->myEth[3], &pPconn->myEth[4], &pPconn->myEth[5]);
    }

    printf("Get [%s], MAC [%02x:%02x:%02x:%02x:%02x:%02x]\n", 
            pPconn->myName, pPconn->myEth[0], pPconn->myEth[1], pPconn->myEth[2], 
            pPconn->myEth[3], pPconn->myEth[4], pPconn->myEth[5]);

            return 1;
}

/*构造PADT数据包，结束PPPOE会话*/
tPPPOEPkt * makepadt(tPPPOEPkt * phead)
{
    unsigned short sessionid;
    sessionid = phead->pppoeHead.sid;
    if (phead != NULL)
    {
        phead->pppoeHead.code= 0xA7;
        phead->pppoeHead.len = 0x0000;      
        phead->pppoeHead.sid = sessionid;
        phead->payload[0] = 0;
    }
    return phead;
}

int main(int argc, char **argv)
{
    int raw_fd = 0;
    int rlen   = 0;
    int n      = 0; 
    char buff[1500] = {0};
    char netcard[6]="eth0";
    tEthHead * pEth= NULL;
    tPPPOEPkt * pPPPhd = NULL;
    int num = 0;
    unsigned short i;
    memset(&myConn, 0, sizeof(tPconn));
    //scanf("%s",&netcard);
	//getchar();
    sprintf(myConn.myName, netcard);
    init_netface(&myConn);

    while (1)
    {

        //send_PADI(&myConn);
        rlen = read(myConn.net_socket, buff, 1514);
        if (rlen > 0)
        {
            pEth = (tEthHead *)buff;        
            /*过滤PPPOE的数据包*/
            //if (ntohs(pEth->proto) == 0x8863)
            //{


                pPPPhd = (tPPPOEPkt *)pEth;
		printf("%u\n",pPPPhd->pppoeHead.sid);
                if (ntohs(pPPPhd->pppoeHead.sid) != 0x0000)
                {
		    printf("!0x0000\n");
                    pPPPhd = makepadt(pPPPhd);
		    //send the changed package
                    rlen = write(myConn.net_socket,(char *)pPPPhd, rlen);
                    printf("the len is %d\n", rlen);

		}
            //}                
        }
        usleep(1000);
    }
    return 0;
}
iteye_8510
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux 使用原始套接字捕捉包
01-26
linux 下的一个小软件，使用原始套接字实现所有的底层抓包分析，注意用root 权限运行
套接字说明
lisayh的博客
08-04 480
套接字是一套用C语言写成的应用程序开发库，它首先是一个库。主要作用就是实现进程间通信和网络编程，因此在网络应用开发中被广泛使用。 套接字（socket）是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。 在Python中可以基于套接字来使用传输层提供的传输服务，并以此进行开发网络应用。实际开发中使用的套接字可以分为三类：流套接字（TCP套接字）、数据报套接字和原始套接字。
数据包收发c语言程序,使用C在套接字编程中创建数据包以及发送和接收数据包的正确方法...
weixin_29774611的博客
05-19 1295
指针pkt未在您的应用程序中定义.您有两种选择：1)将pkt声明为正常变量struct packet pkt;pkt.srcID = 01;....send(sockfd, &pkt, sizeof(struct packet), 0);2)当您的数据包包含一个后跟有效负载的标头时,第二种方法很有用：char buffer[MAX_PACKET_SIZE];struct packet *p...
❤️原始套接字（网络编程再进阶）❤️
m0_46217142的博客
09-28 1905
文章目录TCP、UDP 开发回顾TCP 编程回顾原始套接字的功能 TCP、UDP 开发回顾 数据报式套接字（SOCK_DGRAM） 1、无连接的 socket,针对无连接的 UDP 服务 2、可通过邮件模型来进行对比 流式套接字（SOCK_STREAM） 1、面向连接的 socket,针对面向连接的 TCP 服务 2、可通过电话模型来进行对比 这两类套接字似乎涵盖了 TCP/IP 应用的全部,TCP 与 UDP 各自有独立的 port 互不影响 ,一个进程可同时拥有多个 port,不必关心 tcp/
c语言 原始套接字编程,基于C语言与原始套接字实现Ping程序
weixin_29016833的博客
05-20 732
源代码如下：ping.h#pragma pack(1)//#define u_char unsigned char//#define u_short unsigned short#include#define ICMP_ECHOREPLY 0#define ICMP_ECHOREQ 8//////////////////////////////////typedef struct tagIPDR{...
Linux原始网络编程,Linux操作系统网络编程 原始套接字 （1）
weixin_32868705的博客
05-10 58
Linux操作系统网络编程--原始套接字 (1)http://soft.zdnet.com.cn/software_zone/2007/1020/568223.shtml我们在前面已经学习过了网络程序的两种套接字(SOCK_STREAM,SOCK_DRAGM).在这一章 里面我们一起来学习另外一种套接字--原始套接字(SOCK_RAW)。应用原始套接字,我们可以编写出由TCP和UDP套接字不能够实...
linux下使用原始套接字抓包并发现网络网元，构造数据包，实现过滤规则与数据包统计
03-11
linux下使用原始套接字抓包并发现网络网元，构造数据包，实现过滤规则与数据包统计
Linux 利用原始套接字抓包程序
12-15
linux下利用原始套接字抓取网络数据。用GCC编译，运行时要指定网口,以管理员身份运行Ubuntu下: gcc -o sniffer sniffer.c sudo ./sniffer eth0
使用Linux套接字抓网络包程序
10-18
本主题将深入探讨如何使用Linux原始套接字（raw sockets）来抓取网络数据包，以及`tgsniffer`这个源代码项目。原始套接字允许我们访问网络协议栈的底层，直接处理原始的数据包，而不仅仅是应用层的协议，如TCP或UDP...
C语言实现的网卡监控抓包代码
06-23
综上所述，这个“C语言实现的网卡监控抓包代码”项目涵盖了诸多核心IT概念，包括网络数据包抓取原理、C语言编程、套接字编程、网络协议理解、数据处理和文件I/O操作。对于学习计算机科学的学生而言，完成这样一个...
Linuxc之网络编程讲解及例题
qq_37192076的博客
06-22 981
TCP与UDP：tcp:udp:服务器程序作用初始化服务器程序持续监听一个固定的端口收到客户的连接后建立一个socket连接与客户进行通信和信息处理接收客户通过socket连接发送来的数据，创建一个新的socket，通过socket连接与客户通信，进行相应处理，并返回处理结果通信结束后中断与客户的连接（关闭socket）客户程序作用初始化客户程序连接到某个服务器上，建立socket连接与服务器进行...
linux下c语言抓包,C语言实现抓包工具
weixin_35318150的博客
05-12 2012
本文使用libpcap库在linux下面开发自定义抓包工具，同学们也可以在win下编写同样的代码。抓包的目的：1、分析协议2、伪造数据包3、获取重要信息，例如用户名和密码4、做某些攻击使用抓包的工具(1)Wireshark 可视化的工具(2)Tcpdump是命令行的工具。(3)自定义抓包工具原因1: 只抓取感兴趣的部分，去掉无关紧要的东西，为其他目的服务。原因2：如果有别的目的，例如偷偷安装在别的...
Linux raw socket
weixin_34198762的博客
12-31 606
我们平常所用到的网络编程都是在应用层收发数据，每个程序只能收到发给自己的数据，即每个程序只能收到来自该程序绑定的端口的数据。收到的数据往往只包括应用层数据。某些情况下我们需要执行更底层的操作，比如监听所有本机收发的数据、修改报头等。 通过原始套接字，我们可以抓取所有发送到本机的IP包（包括IP头和TCP/UDP/ICMP包头），也可以抓取所有本机收到的帧（包括数据链路层协议头）。普通的套接字无法...
Linux网络编程--原始套接字
cityday的专栏
07-09 469
原始套接字(SOCKET_RAW)学习总结，主要转载、参考如下博客，部分自己的理解运用： Linux网络编程——原始套接字能干什么？http://blog.csdn.net/tennysonsky/article/details/44655077 通常情况下程序员接所接触到的套接字（Socket）为两类： （1）流式套接字（SOCK_STREAM）：一种面向连接的 Socket，针对
利用原始套接字抓取数据
星愿心愿的专栏
05-10 5035
<br />项目需求，需要从链路层抓包，分析实现网络登录认证功能，现在网上找到两个不错的抓包程序，参考此文章，顺利完成任务，现将此文章收藏与此，便参考，同时感谢文章版主，谢谢！<br /> <br />一：抓包分析：http://blog.csdn.net/aaa6695798/archive/2009/03/20/4008322.aspx<br /> <br />二：原始套接字抓包分析<br /> <br />原始套接字的创建<br />方法1： socket(PF_INET,SOCK_RAW,IPPRO
C++使用原始套接字抓包
a1173356881的博客
05-27 6918
最近在研究使用原始套接字抓包,在网上找各种资料,下面是自己整理的测试代码编程实现主要有以下几个步骤：    1. 初始化WINSOCK库；    2. 创建SOCKET句柄；    3. 绑定SOCKET句柄到一个本地地址；    4. 设置该SOCKET为接收所有数据的模式；    5. 接收数据包；    6. 关闭SOCKET句柄，清理WINSOCK库；#include &lt;stdio....
Linux网络编程——原始套接字编程
热门推荐
秋叶原 && Mike || 麦克
03-27 5万+
原始套接字编程和之前的 UDP 编程差不多，无非就是创建一个套接字后，通过这个套接字接收数据或者发送数据。区别在于，原始套接字可以自行组装数据包（伪装本地 IP，本地 MAC），可以接收本机网卡上所有的数据帧（数据包）。另外，必须在管理员权限下才能使用原始套接字。原始套接字的创建int socket ( int family, int type, int protocol );参数：family：...
利用原始套接字的抓包原理
weixin_43698578的博客
10-28 3684
原始套接字抓包
Linux原始套接字实现分析
最新发布
m0_74282605的博客
03-01 1150
图中TCP、UDP和ICMP协议的接收处理函数分别为tcp_v4_rcv()、udp_rcv()和icmp_rcv()。对于IP报文，在协议栈的ip_local_deliver_finish()函数中会匹配是否有注册的网络层原始套接字，若匹配上就通过skb_clone()克隆报文并交给相应的原始套接字来处理。对于IP报文，在协议栈的ip_local_deliver_finish()函数中会匹配是否有注册的网络层原始套接字，若匹配上就通过skb_clone()克隆报文并交给相应的原始套接字来处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值