精华内容
下载资源
问答
  • 抓取网络数据包

    2015-05-17 15:56:58
    抓取网络数据包当用户在局域网内传递数据时,处于同一网段的所有计算机的网卡都会收到这些数据,尽管它不是传递数据的目的地。利用这一特点,我们就可以截获局域网中传递的数据。为了能够获取通过网卡上的数据,需要...

    抓取网络数据包

    当用户在局域网内传递数据时,处于同一网段的所有计算机的网卡都会收到这些数据,尽管它不是传递数据的目的地。利用这一特点,我们就可以截获局域网中传递的数据。为了能够获取通过网卡上的数据,需要创建原始套接字。用户可以将socket函数的第二个参数设置为SOCK_RAW来创建原始套接字。例如:

    m_Socket=socket(AF_INET,SOCK_RAW,IPPROTO_IP);

    由原始套接字获得的数据是IP数据报,而不仅仅是一个用户数据。它还包含IP数据头和相应协议的数据头,最后才是用户数据。为了获得用户数据,需要逐一去掉IP数据头及各个协议的数据头。

    //创建套接字,开始监听网络
    void CSniffAppDlg::OnBeginlistn()
    {
        //创建套接字
        m_Sock=socket(AF_INET,SOCK_RAW,IPPROTO_IP);
        char name[128];
        memset(name,0,128);
    
        hostent* phostent;
        phostent=gethostbyname(name);
    
        DWORD ip;
    
        ip=inet_addr(inet_ntoa(*(int_addr)phostent->h_addr_list[0]));
        int timeout=4000; //超时4秒
        //设置接受数据的超时时间
        setsockopt(m_Sock,SOL_SOCKET.SO_RCVTIMEO.(const char *)&timeou.sizeof(timeout));
        sockadd_in_skaddr;
        skaddr.sin_family=AF_INET;
        skaddr.sin_port=htons(700);
        skaddr.sin_addr.S_un.S_addr=ip;
        //绑定地址
        if(bind(m_Sock,(sockaddr*)$skaddr,sizeof(skaddr))==SOCKET_ERROR)
        {
        MessageBox("地址绑定错误");
        return;
        }
        DWORD inBuffer=1;
        DWORD outBuffer[10];
        DWORD reValue=0;
        if(WSAIoctl(m_Sock,SIO_RCVAL,&inBuffer,sizeof(inBuffer),&outBuffer,sizeof(outBuffer),&reValue,NULL)==SOCKET_ERROR)
        {
        MessageBox("设置缓冲区错误。");
        closesocket(m_Sock);
        return;
        }
        else
         m_pThread=AfxBeginThread(ThreadFun.(void*)this);
    
    }
    UINT ThreadFun(LPVOID pFaram) //去除数据头
    {
        CSniffAppDlg* pDlg=static_cast<CSniffAppDlg*>(pParam);
        MSG msg;
        char buffer[1000],sourceip[32],*tempbuf;
        char *ptemp;
    
        BYTE* pData=NULL; //实际数据包中的数据
        UINT sourceport;
        CString str;
        HEADIP* pHeadIP;
        HEADICMP* pHeadICMP;
        HEADUDP* pHeadUDP;
        HEADTCP* pHeadTCP;
        in_addr addr;
        int ret;
        while(TRUE)
        {
            pData=NULL;
            if(PeekMessage(&msg.pDlg->m_hWnd,WM_CLOSE,WM_CLOSE,PM_NOREMOVE))
            {
                closesocket(pDlg->m_Sock);
                break;
            }
            memst(buffer,0,1000);
            ret=recv(pDlg->m_Sock,buffer,1000,0);
            if(ret==SOCKET_ERROR)
                {
                 continue;
                }
                else    //接收到的数据
                {
                    tempbuf=buffer;
                    pHeadIP=(HEADIP*)tempbuf;
                    WORD len=ntohs(pHeadIP->totallen); //获取数据报总长度
                    //获取源IP
                    pDlg->m_List.InsertItem(pDlg->m_List.GetItemCount()."");
                    addr.S_un.S_addr=pHeadIP->sourceIP;
                    ptemp=inet_ntoa(addr);
    
                    pDlg->m_List.SetItemText(pDlg->m_List.GetItemCount()-1,1,ptemp);
                    //获取目的IP
                    addr.S_un.S_addr=pHeadIP->destIP;
                    ptemp=inet_ntoa(addr);
                    pDlg->m_List.SetItemText(pDlg->m_List.GetItemCount()-1,2,ptemp);
    
                    //获取协议名称
                    ptem=get_protoname(pHeadIP->proto);
                    strcpy(sourceip,ptemp);
                    pDlg->m_List.SetItemText(pDlg->m_List.GetItemCount()-1,0,sourceip);
    
                    //获取IP数据报总长度
                    WORD ipSunLen=ntohs(pHeadIP->totallen);
    
                    //IP数据报头总长度
                    int netlen=ipSumLen-ipHeadLen;
    
                    //根据不同的协议获得不同协议的数据
                    switch(pHeadIP-proto)
                    {
                        case IPPROTO_ICMP:
                        {
                            pHeadICMP=(HEADICMP*)(tempbuf+20);
                            pData=(BYTE*)(pHeadICMP)+4;//ICMP数据报头功4个字节
    
                            //获取数据的长度
                            netlen-=4;
                            break;
                        }
    
                        case IPPROTO_UDP:
                        {
                            pHeadUDP=(HEADUDP*)(tempbuf+20);
                            pData=(BYTE*)(pHeadUDP)+8;//UDP数据报头共8个字节
                            sourceport=ntohs(pHeadUDP->SourcePort);
                            str.Format("%d",sourceport);
                            //设置源端口
                            pDlg->m_List.SetItemText(pDlg->m_List.GetItemCount()-1,3,str);
                            str.Empty();
                            netlen-=8;
                            break;
                        }
    
                        case IPPROTO_TCP:
                        {
                            pHeadTCP=(HEADTCP*)(tempbuf+20);
                            sourceport=ntohs(pHeadTCP->SourcePort);
                            pData=(BYTE*)(pHeadTCP)+20;//TCP数据报头共20个字节
                            str.Format("%d",sourceport);
                            //设置源端口
                            pDlg->m_List.SetItemText(pDlg->m_List.GetItemCount()-1,3,str);
                            str.Empty();
                            netlen-=20;
                            break;
                        }
                    }
                    //设置数据大小
                    str.Format("%d",netlen);
                    pDlg->m_List.SetItemText(pDlg->m_List.GetItemCount()-1,4,str);
                    str.Empty();
                    //设置数据
                    if(pData!=NULL)
                    {
                        str.Format("%s",pData);
                        pDlg->m_List.SetItemText(pDlg->m_List.GetItemCount()-1,5,str);
    
                    }
                    str.Empty();
    
                }
        }
        return  0;
    
    }
    
    展开全文
  • 使用Java抓取Socket通信TCP数据包 使用WireShark默认使用的是winpcap去抓本地环回的数据包,需要安装npcap再在Wireshark选择本地环回的网卡抓包 在Java-Socket中,在本地Socket不使用127网段无法与服务端进行通信。 ...

    使用Java抓取Socket通信TCP数据包

    使用WireShark默认使用的是winpcap去抓本地环回的数据包,需要安装npcap再在Wireshark选择本地环回的网卡抓包

    在Java-Socket中,在本地Socket不使用127网段无法与服务端进行通信。
    但是常用的Jcap和Pcap4j都是依据libpcap/winpcap实现的。但是这俩又抓不到本地127网段的数据包。

    所以选择在局域网中使用两台设备进行数据传输并抓取相应数据包

    抓包需要使用的winpcap地址:https://www.winpcap.org/

    使用Pcap4j的Maven依赖

    <dependencies>
        <dependency>
            <groupId>org.pcap4j</groupId>
            <artifactId>pcap4j-core</artifactId>
            <version>1.7.5</version>
        </dependency>
        <dependency>
            <groupId>org.pcap4j</groupId>
            <artifactId>pcap4j-packetfactory-static</artifactId>
            <version>1.7.5</version>
        </dependency>
    </dependencies>
    

    服务端:

    import org.pcap4j.core.*;
    import org.pcap4j.packet.Packet;
    import java.io.IOException;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class TCPServer {
    
        public static void Pcap4j(InetAddress addr){
            {
                //1.Pcap抓取不 了本地127的包
                //2.本地Socket不用127网段的包无法与服务端通信
                try {
                    PcapNetworkInterface nif = Pcaps.getDevByAddress(addr);
                    int snaplen = 64 * 1024;
                    int timeout = 50;
                    //初始化抓包器
                    PcapHandle.Builder phb = new PcapHandle.Builder(nif.getName()).snaplen(snaplen)
                            .promiscuousMode(PcapNetworkInterface.PromiscuousMode.PROMISCUOUS).timeoutMillis(timeout)
                            .bufferSize(1 * 1024 * 1024);
                    PcapHandle handle = phb.build();
                    /** 设置TCP过滤规则 */
                    String filter = "tcp and port 7788";//过滤条件是tcp数据包,端口号为7788
                    handle.setFilter(filter, BpfProgram.BpfCompileMode.OPTIMIZE);
                    PacketListener listener = new PacketListener() {
                        @Override
                        public void gotPacket(Packet packet) {
                            System.out.println(packet);
                            System.out.println("-----------------------------------------");
                        }
                    };
                    handle.loop(3, listener);//loop里设置抓3个数据包,要无限抓设置-1
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) throws IOException, PcapNativeException, NotOpenException {
            ServerSocket serverSocket=new ServerSocket(7788);
            System.out.println("建立服务端");
            InetAddress addr=InetAddress.getLocalHost();
            Pcap4j(addr);
            Socket socket=serverSocket.accept();
            System.out.println("连接成功");
            socket.close();
            serverSocket.close();
        }
    }
    

    客户端:

    import java.io.*;
    import java.net.Socket;
    public class TCPClient {
        public static void main(String[] args) throws IOException {
            Socket socket=new Socket("192.168.43.15",7788);
            System.out.println("客户端连接成功");
            socket.close();
    
        }
    }
    

    运行结果:在这里插入图片描述

    在这里插入图片描述在这里插入图片描述

    展开全文
  •     当我们在做网络安全或者数据探测等工作经常会用到抓包、熟悉的工具有tcpdump、wireshark等,这里我们介绍如何使用C程序原始套接字在linux系统上抓取IP链路层数据包。     首先我们先熟悉一个非常重要的...

    基于linux的抓包

    一、获取数据

        当我们在做网络安全或者数据探测等工作经常会用到抓包、熟悉的工具有tcpdump、wireshark等,这里我们介绍如何使用C程序原始套接字在linux系统上抓取IP链路层数据包。

        首先我们先熟悉一个非常重要的函数socket,我们可以通过linux的man手册找到socket函数描述

    #include <sys/socket.h>
    
         int
         socket(int domain, int type, int protocol);
         DESCRIPTION
    
         socket() creates an endpoint for communication and returns a descriptor.
    
         The domain parameter specifies a communications domain within which com-
         munication will take place; this selects the protocol family which should
         be used.  These families are defined in the include file <sys/socket.h>.
         The currently understood formats are
    
               PF_LOCAL        Host-internal protocols, formerly called PF_UNIX,
               PF_UNIX         Host-internal protocols, deprecated, use PF_LOCAL,
               PF_INET         Internet version 4 protocols,
               PF_ROUTE        Internal Routing protocol,
               PF_KEY          Internal key-management function,
               PF_INET6        Internet version 6 protocols,
               PF_SYSTEM       System domain,
               PF_NDRV         Raw access to network device
    
         The socket has the indicated type, which specifies the semantics of com-
         munication.  Currently defined types are:
    
               SOCK_STREAM
               SOCK_DGRAM
               SOCK_RAW
    
         A SOCK_STREAM type provides sequenced, reliable, two-way connection based
         byte streams.  An out-of-band data transmission mechanism may be sup-
         ported.  A SOCK_DGRAM socket supports datagrams (connectionless, unreli-
         able messages of a fixed (typically small) maximum length).  SOCK_RAW
         sockets provide access to internal network protocols and interfaces.  The
         type SOCK_RAW, which is available only to the super-user.
    
         The protocol specifies a particular protocol to be used with the socket.
         Normally only a single protocol exists to support a particular socket
         type within a given protocol family.  However, it is possible that many
         protocols may exist, in which case a particular protocol must be speci-
         fied in this manner.  The protocol number to use is particular to the
         communication domain in which communication is to take place; see
         protocols(5).
    
         Sockets of type SOCK_STREAM are full-duplex byte streams, similar to
         pipes.  A stream socket must be in a connected state before any data may
         be sent or received on it.  A connection to another socket is created
         with a connect(2) or connectx(2) call.  Once connected, data may be
         transferred using read(2) and write(2) calls or some variant of the
         send(2) and recv(2) calls.  When a session has been completed a close(2)
         may be performed.  Out-of-band data may also be transmitted as described
         in send(2) and received as described in recv(2).
    
         The communications protocols used to implement a SOCK_STREAM insure that
         data is not lost or duplicated.  If a piece of data for which the peer
         protocol has buffer space cannot be successfully transmitted within a
         reasonable length of time, then the connection is considered broken and
         calls will indicate an error with -1 returns and with ETIMEDOUT as the
         specific code in the global variable errno.  The protocols optionally
         keep sockets ``warm'' by forcing transmissions roughly every minute in
         the absence of other activity.  An error is then indicated if no response
         can be elicited on an otherwise idle connection for a extended period
         (e.g. 5 minutes).  A SIGPIPE signal is raised if a process sends on a
         broken stream; this causes naive processes, which do not handle the sig-
         nal, to exit.
    
         SOCK_DGRAM and SOCK_RAW sockets allow sending of datagrams to correspon-
         dents named in send(2) calls.  Datagrams are generally received with
         recvfrom(2), which returns the next datagram with its return address.
    
         An fcntl(2) call can be used to specify a process group to receive a
         SIGURG signal when the out-of-band data arrives.  It may also enable non-
         blocking I/O and asynchronous notification of I/O events via SIGIO.
    
         The operation of sockets is controlled by socket level options.  These
         options are defined in the file <sys/socket.h>.  Setsockopt(2) and
         getsockopt(2) are used to set and get options, respectively.
    
    
    

    简单描述一下,socket函数创建一个套接字描述符,如何创建这个描述符由它三个参数决定

    参数说明:

    1. domain --指定要选择哪种协议簇来进行通信,如果做过tcp或udp通信,相信对“PF_INET”不陌生把,他表示socket通信在IPV4网络层,如果你想使用IPV6那么可以选择“PF_INET6”,我要说的是我们在这里如果要想获得MAC地址则需要指定通信域在链路层,可以选择“PF_PACKET”

    2. type --指定通信类型,如果我们是TCP通信可选择数据流“SOCK_STREAM”,如果是UDP可选择"SOCK_DGRAM",指的注意的是“SOCK_RAW”它提供一个对内部网络访问的接口,这里我们抓包就要用到它

    3. protocol–通常情况下可以是0,由于我们前面两个参数的选择这里我们选择“ETH_P_IP”

    下面是sock的创建部分代码

    #include <sys/socket.h>
    #include <linux/if_ether.h>
    #include <netinet/in.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    int main()
    {
        int sock;
        if ((sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP))) < 0)
        {
            perror(strerror(errno));
            fprintf(stdout, "create socket error\n");
            exit(0);
        }
        
    }
    

    从函数描述了解到SOCK_RAW的sockets是可以通过recvfrom来接收数据,我们就是通过他来获取IP数据

    bzero(buffer, sizeof(buffer));
    n_read = recvfrom(sock, buffer, 2048, 0, NULL, NULL);
    if (n_read <0) {
        exit(0);
    }
    

    此时我们抓到的buffer中的数据就是链路层数据

    二、tcp数据包解析

    链路层数据格式
    各层数据描述
    如图红色框中的部分,是我们抓取到的数据包括:

    • 链路层包头:其中包括“目的地址+源地址+类型”
    • 链路层数据:IP数据包
    • CRC校验

    然而我们需要解析的是TCP数据,TCP数据包属于传输层数据,被包含在网络层IP数据包中,所以我们需要从下到上一层一层解析数据

    根据对传输层的描述,先定义一个链路层包头的数据格式,方便使用代码解析

    //MAC header
    typedef struct {
    unsigned char DesMacAddr[6];  //6字节目的MAC地址
    unsigned char SrcMacAddr[6];   //6字节源MAC地址
    short LengthOrType; //两个字节的网络类型
    }__attribute__((packed)) MAC_HEADER, *PMAC_HEADER;
    

    IP数据包
    在这里插入图片描述

    typedef struct {
    unsigned char hdr_len: 4;
    unsigned char version: 4;
    unsigned char tos;
    unsigned short total_len;
    unsigned short identifier;
    unsigned short frag_and_flags;
    unsigned char ttl;
    unsigned char protocol;
    unsigned short checksum;
    unsigned int source_ip;
    unsigned int dest_ip;
    }__attribute__((packed)) IP_HEADER, *PIP_HEADER;  
    

    TCP数据包
    在这里插入图片描述

    //IP header
    typedef struct {
    unsigned char hdr_len: 4;
    unsigned char version: 4;
    unsigned char tos;
    unsigned short total_len;
    unsigned short identifier;
    unsigned short frag_and_flags;
    unsigned char ttl;
    unsigned char protocol;
    unsigned short checksum;
    unsigned int source_ip;
    unsigned int dest_ip;
    }__attribute__((packed)) IP_HEADER, *PIP_HEADER; 
    

    以下是对各个部分的解析过程代码

    /********************mac header*******************/
    
    PMAC_HEADER pmacHeader = (MAC_HEADER *) buffer;
    printf("Source Mac:");
    for (i = 0; i < 6; ++i) {
        printf("%02x", pmacHeader->SrcMacAddr[i]);
    }
    printf("  ");
    printf("Dest Mac:");
    for (i = 0; i < 6; ++i) {
        printf("%02x", pmacHeader->DesMacAddr[i]);
    }
    printf("\n");
        /********************ip header**********************/
    PIP_HEADER pipHeader = (PIP_HEADER) (buffer + MAC_HEADER_SIZE);
    
    int total_len = ntohs(pipHeader->total_len);
    ip_header_len = pipHeader->hdr_len * 4;
    
    if (ip_header_len > 20 || ip_header_len > 60)
    {
        exit(0);
    }
    
    memcpy(&des_addr, &pipHeader->dest_ip, 4);
    memcpy(&src_addr, &pipHeader->source_ip, 4);
    
    int proto = pipHeader->protocol;
    switch (proto) {
        case IPPROTO_ICMP:
            printf("ICMP\n");
            break;
        case IPPROTO_IGMP:
            printf("IGMP\n");
            break;
        case IPPROTO_IPIP:
            printf("IPIP\n");
            break;
        case IPPROTO_TCP :
            printf("TCP:");
            PTCP_HEADER tcpHeader = (PTCP_HEADER) (buffer + MAC_HEADER_SIZE + ip_header_len);
            tcp_header_len = ((tcpHeader->m_uiHeadOff & 0xf0) >> 4) * 4;
            int data_len = total_len - ip_header_len - tcp_header_len;
            printf("%s.%d-->%s.%d Len:%d\n", inet_ntoa(src_addr), tcpHeader->m_sSourPort, inet_ntoa(des_addr),
                   tcpHeader->m_sDestPort, data_len);
            int tcp_data_index = MAC_HEADER_SIZE + ip_header_len + tcp_header_len;
            unsigned char *p = buffer + tcp_data_index;
    
            if (data_len > 0) {
                printf("Data:");
                for (int k = 0; k < n_read - tcp_data_index; ++k) {
                    printf("%02x ", p[k]);
                }
                //printf("\n");
                for (int k = 0; k < n_read - tcp_data_index; ++k) {
                    printf("%c", p[k]);
                }
                printf("\n");
            }
            break;
        case IPPROTO_UDP :
            printf("UDP\n");
            break;
        case IPPROTO_RAW :
            printf("RAW\n");
            break;
        default:
            printf("Unkown\n");
    }
    

    运行结果:

    IP Source Mac:9ca615de20d0  Dest Mac:94c6919aa8f4
    TCP:222.131.155.252.56539-->222.131.155.252.5632 Len:0
    IP Source Mac:b888e3dc810e  Dest Mac:ffffffffffff
    UDP
    IP Source Mac:9ca615de20d0  Dest Mac:94c6919aa8f4
    TCP:222.131.155.252.56539-->222.131.155.252.5632 Len:52
    Data:c7 e4 e1 18 5c b8 44 91 34 bc a2 2d b8 da ae 64 52 8f ab 3d f8 70 db db 65 2c 2d 2c 9a cd 2d 02 54 e5 db d2 5c 54 8c 7d 1d fe 05 1e c7 d8 e4 b9 23 d8 09 fc ���\�D�4��-�ڮdR��=�p��e,-,��-T���\T�}����#�	�
    

    点击获取Github源码

    展开全文
  • 嗅探器作为一种网络通讯程序,也是通过对网卡的编程来实现网络通讯的,对网卡的编程也是使用通常的套接字(socket)方式来进行。但是,通常的套接字程序只能响应与自己硬件地址相匹配的或是以广播形式发出的数据帧,...
    嗅探器作为一种网络通讯程序,也是通过对网卡的编程来实现网络通讯的,对网卡的编程也是使用通常的套接字(socket)方式来进行。但是,通常的套接字程序只能响应与自己硬件地址相匹配的或是以广播形式发出的数据帧,对于其他形式的数据帧比如已到达网络接口但却不是发给此地址的数据帧,网络接口在验证投递地址并非自身地址之后将不引起响应,也就是说应用程序无法收取到达的数据包。而网络嗅探器的目的恰恰在于从网卡接收所有经过它的数据包,这些数据包即可以是发给它的也可以是发往别处的。显然,要达到此目的就不能再让网卡按通常的正常模式工作,而必须将其设置为混杂模式。
    具体到编程实现上,这种对网卡混杂模式的设置是通过原始套接字(raw socket)来实现的,这也有别于通常经常使用的数据流套接字和数据报套接字。在创建了原始套接字后,需要通过setsockopt()函数来设置IP头操作选项,然后再通过bind()函数将原始套接字绑定到本地网卡。为了让原始套接字能接受所有的数据,还需要通过ioctlsocket()来进行设置,而且还可以指定是否亲自处理IP头。至此,实际就可以开始对网络数据包进行嗅探了,对数据包的获取仍象流式套接字或数据报套接字那样通过recv()函数来完成。但是与其他两种套接字不同的是,原始套接字此时捕获到的数据包并不仅仅是单纯的数据信息,而是包含有 IP头、 TCP头等信息头的最原始的数据信息,这些信息保留了它在网络传输时的原貌。通过对这些在低层传输的原始信息的分析可以得到有关网络的一些信息。由于这些数据经过了网络层和传输层的打包,因此需要根据其附加的帧头对数据包进行分析。下面先给出结构.数据包的总体结构:
    数据包
    IP头 TCP头(或其他信息头) 数据

    数据在从应用层到达传输层时,将添加TCP数据段头,或是UDP数据段头。其中UDP数据段头比较简单,由一个8字节的头和数据部分组成,具体格式如下:
    16位 16位
    源端口 目的端口
    UDP长度 UDP校验和

    而TCP数据头则比较复杂,以20个固定字节开始,在固定头后面还可以有一些长度不固定的可选项,下面给出TCP数据段头的格式组成:
    16位 16位
    源端口 目的端口
    顺序号
    确认号
    TCP头长 (保留)7位 URG ACK PSH RST SYN FIN 窗口大小
    校验和 紧急指针
    可选项(0或更多的32位字)
    数据(可选项)

    对于此TCP数据段头的分析在编程实现中可通过数据结构_TCP来定义:
    [cpp] view plain copy
    1. typedef struct _TCP{ WORD SrcPort; // 源端口  
    2. WORD DstPort; // 目的端口  
    3. DWORD SeqNum; // 顺序号  
    4. DWORD AckNum; // 确认号  
    5. BYTE DataOff; // TCP头长  
    6. BYTE Flags; // 标志(URG、ACK等)  
    7. WORD Window; // 窗口大小  
    8. WORD Chksum; // 校验和  
    9. WORD UrgPtr; // 紧急指针  
    10. } TCP;  
    11. typedef TCP *LPTCP;  
    12. typedef TCP UNALIGNED * ULPTCP;  



    在网络层,还要给TCP数据包添加一个IP数据段头以组成IP数据报。IP数据头以大端点机次序传送,从左到右,版本字段的高位字节先传输(SPARC是大端点机;Pentium是小端点机)。如果是小端点机,就要在发送和接收时先行转换然后才能进行传输。IP数据段头格式如下:
    16位 16位
    版本 IHL 服务类型 总长
    标识 标志 分段偏移
    生命期 协议 头校验和
    源地址
    目的地址
    选项(0或更多)

    同样,在实际编程中也需要通过一个数据结构来表示此IP数据段头,下面给出此数据结构的定义:
    [cpp] view plain copy
    1. typedef struct _IP{  
    2. unionBYTE Version; // 版本  
    3. BYTE HdrLen; // IHL  
    4. };  
    5. BYTE ServiceType; // 服务类型  
    6. WORD TotalLen; // 总长  
    7. WORD ID; // 标识  
    8. unionWORD Flags; // 标志  
    9. WORD FragOff; // 分段偏移  
    10. };  
    11. BYTE TimeToLive; // 生命期  
    12. BYTE Protocol; // 协议  
    13. WORD HdrChksum; // 头校验和  
    14. DWORD SrcAddr; // 源地址  
    15. DWORD DstAddr; // 目的地址  
    16. BYTE Options; // 选项  
    17. } IP;   
    18. typedef IP * LPIP;  
    19. typedef IP UNALIGNED * ULPIP;  



    在明确了以上几个数据段头的组成结构后,就可以对捕获到的数据包进行分析了。
    展开全文
  • 抓取PC客户端的数据包 (以客户端软件”网易有道词典“演示客户端抓包,默认是抓不到的) 0x01 Fiddler抓不到数据原因 Fiddler为什么抓不到PC端数据包,只能抓取: 浏览器数据包 程序使用WinInet库进行...
  • 通过socket开发智能硬件APP,少不了要去抓取硬件和APP之间的通信数据。今天就给大家介绍一款配合Wireshark抓取数据包的神器rvictl。 步骤: 1.将iPhone通过数据线,连上Mac,并打开iTunes,复制设备UDID。 2.打开...
  • Linux系统抓取数据包

    千次阅读 2015-07-10 11:49:34
    这篇文章介绍了Linux下如何实现定制化的类wireshark程序的一些要点(不需要装pcap,利用Linux 的 socket 自带的一些功能)。 Ethernet frame 参考资料:  https://en.wikipedia.org/wiki/Ethernet_frame  ...
  • wireshark 抓取本地回环数据包

    千次阅读 2013-09-13 14:48:16
    通常wireshark中不可以直接抓取本地的回环数据包,比如写一个小socket程序,client和server都在本地,这种数据包wireshark是不能直接抓取的。 但可以通过以下配置达到此目的: windows下,在命令行中输入以下语句 ...
  • 应用程序使用RAW socket从内核中抓取指定协议的数据包流程分析; 应用程序: int init_sockets() {  struct ifreq ifr;  struct sockaddr_ll addr;  struct sockaddr_in addr2;    drv->sock =...
  • wireshark中抓取本地回环数据包

    万次阅读 热门讨论 2011-04-30 21:42:00
    通常wireshark中不可以直接抓取本地的回环数据包,比如写一个小socket程序,client和server都在本地,这种数据包wireshark是不能直接抓取的。但可以通过以下配置达到此目的:windows下,在命令行中输入以下语句:...
  • 原始套接字介绍关于socket使用客户机/服务器模型的 SOCK_STREAM 或者 SOCK_DGRAM 用于 TCP 和 UDP 连接的应用更为普遍一些,而如果考虑到从网卡中直接捕获原始报文数据就需要用到原始套接字 SOCK_RAW 类型了。...
  • 编译运行DaytimeClient,访问"time.nist.gov"获取时间信息。 package tcpClient.daytime; import java.io.IOException;import java.io.InputStream;...import java.net.Socket;importjava.nio.c...
  • wireshark如何抓取本地socket

    千次阅读 2017-06-26 14:05:34
    wireshark如何抓取本机包  在进行通信开发的过程中...但是wireshark此时是无法抓取数据包的,需要通过简单的设置才可以。   具体方法如下:  1.以管理员身份运行cmd  2.route add 本机ip mask 255.2
  • 通常wireshark中不可以直接抓取本地的回环数据包,比如写一个小socket程序,client和server都在本地,这种数据包wireshark是不能直接抓取的。但可以通过以下配置达到此目的: windows下,在命令行中输入以下语句...
  • 而libpcap虽然是基于socket实现抓包,但在收到数据包后,会进一步恢复出剥离的VLAN信息,能够满足需要抓取带VLAN标签信息的数据包的需求场景。 python-pypcap包是对libpcap库的python语言封装,本文主要介绍如果利用...
  • 最近实验室布置了一个作业:首先编写通信程序,后利用wireshark对我编写的通信程序中传递的数据包进行抓取并进行解析。 一、本地回环数据包抓取 首先是通信程序的编写,编写了基于socket的通信程序,为了简便...
  • sys/socket.h> #include<sys/ioctl.h> #include<unistd.h> #include<sys/types.h> #include<sys/stat.h> #include<fcntl.h> #include<errno.h> #include<linux/if...
  • C# Socket 同步发收数据包探讨

    千次阅读 2009-05-31 15:25:00
    本来是想研究一下基于HTTP协议和TCP协议数据包的发送与接收,对基本HTTP来说,用SOAP再好不过了,但对于IE中的某些包,比如:Flash,SOAP显得无能为力,就本人目前的知识面来说,只能通过Socket抓取它(正在学习中...
  • 使用socket编程实现IP协议数据帧的抓取: #include "stdafx.h" #include #pragma comment(lib,"ws2_32.lib") #define MAX_HOSTNAME_LAN 255 #define SIO_RCVALL _WSAIOW(IOC_VENDOR,1) #define MAX_ADDR_LEN 16 /...
  • 网卡抓取--2(监听数据包

    千次阅读 2016-05-01 23:13:28
    JAVA的Socket主要在传输层,而网卡,则主要工作在数据链路层,那么JAVA监听数据包,就需要其他包的支持。 首先下载Winpcap,安装好。然后下载Jpcap,解压缩,将jpcap.dll放入jdk安装路径的bin目录下和jre安装路径的...
  • 首先贴上源代码 #include <...sys/socket.h> #include <sys/types.h> #include <arpa/inet.h> #include <cstdlib> //协议相关结构体 #include <netinet/if_ether.h> int main
  • 很干净 精巧的数据包抓取工具 insocket expert06b1 可以使用于WEB开发、数据包抓取、信息截获 如果不安装sniffer 那么可以考虑下这个哦
  • RAW SOCKET探索

    2020-07-27 18:00:11
    在Linux实现抓取以太网络上的数据包主要有libpcap,raw socket以及从内核中获取的方式。 我尝试选择使用raw socket抓取以太网络上的数据包。 一、socket地址域(协议簇) 在Linux的manual中,有两个篇包含socket...
  • 我们在做app网络流量分析的第一步就是先抓取流量数据包,抓包一般又分为以下两种情形: 应用层抓包:Http(s)协议抓包,常用抓包工具有Charles、Burpsuite、Wireshark。 会话层抓包:Socket端口通信抓包,用Socket...
  • Linux的RAW SOCKET探索

    2019-09-17 14:01:12
    在Linux实现抓取以太网络上的数据包主要有libpcap,raw socket以及从内核中获取的方式。 我尝试选择使用raw socket抓取以太网络上的数据包。 ##socket地址域(协议簇)## 在Linux的manual中,有两个篇包含socket...
  • 想利用winpcap抓取数据包。去除mac与ip头后利用socket发送到本机应用程序。不知这样做是否可行。暂时不考虑rawsocket抓包

空空如也

空空如也

1 2 3 4
收藏数 64
精华内容 25
关键字:

抓取socket数据包