отправка из winpcap

как правильно отправлять пакеты?

 

снифер не ловит пакет

 

обновленная версия

Код (Text):

1.  
2. #include "Include/pcap.h"  /* Libpcap  */
3. #include "Include/pcap-stdinc.h"
4. #include "Include/Packet32.h"
5. #include "ip.h"  /* Internet Protocol  */
6. #include "tcp.h"  /* Transmission Control Protocol */
7. #include <string.h>  /* String operations  */
8. #include <stdlib.h>  /* Standard library definitions  */
9.  
10. #define TCPSYN_LEN 20
11. /* Pseudoheader (Used to compute TCP checksum. Check RFC 793) */
12. typedef struct PSEUDOHEADER {
13.    unsigned int src;
14.    unsigned int dst;
15.    unsigned char zero;
16.    unsigned char protocol;
17.    unsigned short tcplen;
18. } tcp_phdr_t;
19.  
20. typedef unsigned short u_int16;
21. typedef unsigned long u_int32;
22.  
23. typedef struct ETHHEADER {
24.    unsigned char EthDest[6];   /* destination eth addr   */
25.    unsigned char EthSource[6];   /* source ether addr   */
26.    short EthProto;     /* packet type ID field   */
27. } ethhdr;
28. unsigned short in_cksum(unsigned short *addr,int len);
29.  
30. unsigned short dst_prt = htons(80);
31. int src_ip = inet_addr("192.168.56.101");
32. unsigned short src_prt = htons(80);
33. int dst_ip = inet_addr("192.168.56.1");
34.  
35. VOID Send(){
36.  
37.  
38.    char error[PCAP_ERRBUF_SIZE] = {0};
39.    char *dev;
40.    ethhdr EthHeader;
41.    pcap_t *descr;
42.    /*get device*/
43.    dev=pcap_lookupdev(error);
44.    if (dev == NULL) {
45.      fprintf(stderr, "Couldn't find default device: %s\n", error);
46.      return;
47.    }
48.  
49.    /*Open the device */
50.    if((descr = pcap_open_live(dev, 100, 1, 1000, error) ) == NULL)
51.    {
52.      fprintf(stderr,"\nError opening device: %s\n", error);
53.      return;
54.    }
55.    printf("\ndevice: %s\n", dev );
56.  
57.    EthHeader.EthDest[0] = 0x0a;
58.    EthHeader.EthDest[1] = 0x00;
59.    EthHeader.EthDest[2] = 0x27;
60.    EthHeader.EthDest[3] = 0x00;
61.    EthHeader.EthDest[4] = 0x00;
62.    EthHeader.EthDest[5] = 0x0d;
63.  
64.    EthHeader.EthSource[0] = 0x11;
65.    EthHeader.EthSource[1] = 0x11;
66.    EthHeader.EthSource[2] = 0x11;
67.    EthHeader.EthSource[3] = 0x11;
68.    EthHeader.EthSource[4] = 0x11;
69.    EthHeader.EthSource[5] = 0x11;
70.  
71.    EthHeader.EthProto = htons(0x08FF);
72.  
73.    static int i=0;
74.    char one=1; /* R.Stevens says we need this variable for the setsockopt call */
75.  
76.    /* Raw socket file descriptor */
77.    /* Buffer for the TCP/IP SYN Packets */
78.    char packet[ sizeof(EthHeader)+ sizeof(ip) +1 ]  = {0};  // + sizeof(tcphdr)
79.    /* It will point to start of the packet buffer */  
80.    ip ipheader;  
81.    /* It will point to the end of the IP header in packet buffer */  
82.    tcphdr tcpheader;
83.    /* TPC Pseudoheader (used in checksum)  */
84.    tcp_phdr_t pseudohdr;  
85.    /* TCP Pseudoheader + TCP actual header used for computing the checksum */
86.    char tcpcsumblock[ sizeof(tcp_phdr_t) + TCPSYN_LEN ];
87.  
88.    /* IP Header */
89.    ipheader.ip_hl = (sizeof(ip) >> 2);  /* Header lenght in octects  */
90.    ipheader.ip_v = 4;  /* Ip protocol version (IPv4)  */
91.    ipheader.ip_len = htons(sizeof(ip));// + sizeof (struct tcphdr) );  
92.    ipheader.ip_ttl = 255;  /* Time to live: 64 in Linux, 128 in Windows...  */
93.    ipheader.ip_p = 6;  /* Transport layer prot. TCP=6, UDP=17, ICMP=1... */
94.    
95.    ipheader.ip_id = htons( 1337 );
96.    ipheader.ip_src.s_addr = inet_addr("192.168.56.101");  /* Source IP address  */
97.    ipheader.ip_dst.s_addr = inet_addr("192.168.56.1");  /* Destination IP address  */
98.    /* TCP Header */  
99.    tcpheader.th_seq = 0;  /* Sequence Number  */
100.    tcpheader.th_ack = htonl(1);  /* Acknowledgement Number  */
101.    tcpheader.th_x2 = 0;  /* Variable in 4 byte blocks. (Deprecated) */
102.    tcpheader.th_off = 5;      /* Segment offset (Lenght of the header)  */
103.    tcpheader.th_flags = TH_RST;  /* TCP Flags. We set the Reset Flag  */
104.    tcpheader.th_win = htons(4500) + rand()%1000;/* Window size  */
105.    tcpheader.th_urp = 0;  /* Urgent pointer.  */
106.    tcpheader.th_sport = htons(11131);  /* Source Port  */
107.    tcpheader.th_dport = htons(80);  /* Destination Port  */
108.    tcpheader.th_sum=0;  /* Checksum. (Zero until computed)  */
109.    /* Fill the pseudoheader so we can compute the TCP checksum*/
110.    pseudohdr.src = ipheader.ip_src.s_addr;
111.    pseudohdr.dst = ipheader.ip_dst.s_addr;
112.    pseudohdr.zero = 0;
113.    pseudohdr.protocol = ipheader.ip_p;
114.    pseudohdr.tcplen = htons( sizeof(tcphdr) );
115.  
116.    /* Copy header and pseudoheader to a buffer to compute the checksum */  
117.    memcpy(tcpcsumblock, &pseudohdr, sizeof(tcp_phdr_t));  
118.    memcpy(tcpcsumblock+sizeof(tcp_phdr_t),&tcpheader, sizeof(tcphdr));
119.  
120.    /* Compute the TCP checksum as the standard says (RFC 793) */
121.    tcpheader.th_sum = in_cksum((unsigned short *)(tcpcsumblock), sizeof(tcpcsumblock));
122.    /* Compute the IP checksum as the standard says (RFC 791) */
123.    ipheader.ip_sum = in_cksum((unsigned short *)&ipheader, sizeof(ip));
124.  
125.    memcpy(packet, &EthHeader, sizeof(ethhdr));
126.    memcpy(packet+sizeof(ethhdr), &ipheader, sizeof(ip));
127.    ///memcpy(packet+sizeof(EthHeader)+sizeof(struct tcphdr), tcpheader, sizeof(struct tcphdr));
128.    if(pcap_sendpacket(descr,(u_char *)packet,sizeof(packet))==-1)
129.      perror("pcap_sendpacket");
130.    else
131.      printf("packet sent");
132.    
133.    printf("Sent RST Packet:\n");
134.    printf("  SRC: %s:%d\n", inet_ntoa(ipheader.ip_src), ntohs(tcpheader.th_sport));
135.    printf("  DST: %s:%d\n", inet_ntoa(ipheader.ip_dst), ntohs(tcpheader.th_dport));
136.    printf("  Seq=%u\n", ntohl(tcpheader.th_seq));
137.    printf("  Ack=%d\n", ntohl(tcpheader.th_ack));
138.    printf("  TCPsum: %02x\n",  tcpheader.th_sum);
139.    printf("  IPsum: %02x\n", ipheader.ip_sum);
140.    printf("  PACKET=%s\n", packet);
141.    
142. }
143. /* This piece of code has been used many times in a lot of differents tools. */
144. /* I haven't been able to determine the author of the code but it looks like */
145. /* this is a public domain implementation of the checksum algorithm */
146. unsigned short in_cksum(unsigned short *addr,int len){
147.  
148.    int sum = 0;
149.    unsigned short answer = 0;
150.    unsigned short *w = addr;
151.    int nleft = len;
152.  
153.    /*
154.    * Our algorithm is simple, using a 32-bit accumulator (sum),
155.    * we add sequential 16-bit words to it, and at the end, fold back
156.    * all the carry bits from the top 16 bits into the lower 16 bits.
157.    */
158.  
159.    while (nleft > 1) {
160.      sum += *w++;
161.      nleft -= 2;
162.    }
163.  
164.    /* mop up an odd byte, if necessary */
165.    if (nleft == 1) {
166.      *(unsigned char *)(&answer) = *(unsigned char *)w ;
167.      sum += answer;
168.    }
169.  
170.    /* add back carry outs from top 16 bits to low 16 bits */
171.    sum = (sum >> 16) + (sum &0xffff); /* add hi 16 to low 16 */
172.    sum += (sum >> 16); /* add carry */
173.    answer = ~sum; /* truncate to 16 bits */
174.    return(answer);
175.  
176. }
177.