一款简单易用的 DNS 发包工具

1）执行make，编译
2）修改client.conf
3）根据需要修改要发送的域名 改query_domain
4）根据需要修改发包数量，时间间隔等 改start.sh
5）执行./start.sh
6）查看 ./start.sh print
7）关闭 ./start.sh kill

容易犯的错误
1）client.conf 配置没有改对。源ip和目的ip不能相同。一般来说目的比源大
2）域名后面没有加. 只支持A
3）start.sh路径不对

Makefile

senddns : senddns.o
    gcc -g -o senddns senddns.c
.PHONY : clean
clean :
    rm -f *.o senddns

startdns.sh

if [ "kill" = $1 ]
then
    killall senddns
elif [ "print" = $1 ]
then
    ps -ef|grep senddns|grep -v grep
else
    for((i=1;i<=1;i++))
    do
        /root/senddns/senddns @client.conf 100 1000000 1000&
    done
fi

client.conf

#start source ip
--start_sip 192.168.100.58

#stop source ip
--end_sip   192.168.100.60

#exclude source IP list, space to separate 
--exclude_sip 192.168.100.50 192.168.100.51 192.168.100.52 192.168.100.100

#start source port, must be more than 1024
--start_sport 2000

#stop source port, must be less than 65535
--end_sport 60000

#direction IP
--targetip 192.168.100.100

#direction port
--targetport 53

#query domain list file
--queryfile  query_domain.txt

query_domain.txt

www.sabadeda.com. A
bbs.sabadeda.com. A
edu.paidai.com. A
news.paidai.com. A
z.paidai.com. A
x.paidai.com. A
my.paidai.com. A
bbs.paidai.com. A

senddns.c

#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <pthread.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>

int debug_flag = 0;
void sig_proc(int signum);

#define LOG_DEBUG(fmt, args...)                                     \
    do { if (debug_flag) printf(fmt,##args); } while (0)


typedef struct ip_hdr
{
    unsigned char     h_verlen;
    unsigned char     tos;
    unsigned short    total_len;
    unsigned short    ident;
    unsigned short    frag_and_flags;
    unsigned char     ttl;
    unsigned char     proto;
    unsigned short    checksum;
    unsigned int      sourceIP;
    unsigned int      destIP;
}IP_HEADER;

typedef struct udp_hdr
{
    unsigned short    uh_sport;
    unsigned short    uh_dport;
    unsigned short    uh_length;
    unsigned short    uh_checksum;
}UDP_HEADER;

typedef struct usd_hdr
{
    unsigned long       saddr;
    unsigned long       daddr;
    char                mbz;
    char                ptcl;
    unsigned short      udpl;
}USD_HEADER;

typedef struct dns
{
    unsigned short    tid;
    unsigned short    flags;
    unsigned short    queries;
    unsigned short    answers;
    unsigned short    auth;
    unsigned short    additional;
}DNS_HEADER;

typedef struct query
{
    char *    name;
    unsigned short    type;
    unsigned short    class;
}QUERY_HEADER;

unsigned long long sleeptime, starttime, outcount = 0, max_pkts=0;
int pkt_then_sleep = 0;
FILE *fp_query = NULL;

struct send_conf {
   unsigned int threadnum;
   unsigned int start_sip;
   unsigned int end_sip;
   unsigned int exclude_sip_num;
   unsigned int exclude_sip_list[1024];
   unsigned int start_sport;
   unsigned int end_sport;    
   unsigned int targetip;
   unsigned int targetport;
   unsigned char query_file[1024];
} send_config;

IP_HEADER   IpHeader;
UDP_HEADER  UdpHeader;
USD_HEADER  UsdHeader;
DNS_HEADER  DnsHeader;
QUERY_HEADER    QueryHeader;
char query_domain[1024] = {0};

unsigned short CheckSum(unsigned short * buffer, int size)
{
    unsigned long   cksum = 0;

    while (size > 1)
    {
        cksum += *buffer++;
        size -= sizeof(unsigned short);
    }
    if (size)
    {
        cksum += *(unsigned char *) buffer;
    }
    cksum = (cksum >> 16) + (cksum & 0xffff);
    cksum += (cksum >> 16);

    return (unsigned short) (~cksum);
}

void MySleep(unsigned int micro_second)
{
    struct timeval  t_timeval;

    t_timeval.tv_sec = 0;
    t_timeval.tv_usec = micro_second;

    select( 0, NULL, NULL, NULL, &t_timeval );
}

void PaddingQuery( char *buffer, char *domain_name)
{
    char *tmp = (char *)malloc(strlen(domain_name)+1);
    if( NULL == tmp )
    {
        fprintf( stderr, "malloc for query error: %s\n", strerror(errno) );
        exit(-1);
    }
    memset( tmp, 0, strlen(domain_name)+1 );
    memset(query_domain, 0, sizeof(query_domain));

    strncpy(tmp, domain_name, strlen(domain_name));
    strncpy(query_domain, tmp, sizeof(query_domain));

    int length_pos = 0;
    int loop_num = 1;

    char *token = strtok( tmp, "." );
    while( NULL != token )
    {
        if( loop_num == 1 )
        {
            length_pos = 0;
            memset( buffer, strlen(token), 1 );
            strcpy( buffer+length_pos+1, token );

            length_pos = length_pos + strlen(token) + 1;
        }
        else
        {
            memset( buffer+length_pos, strlen(token), 1 );
            strcpy( buffer+length_pos+1, token );

            length_pos = length_pos + strlen(token) + 1;
        }

        token = strtok( NULL, "." );
        loop_num ++;
    }

    free(tmp);
}

void Init( char *buffer, int buffer_size, struct send_conf *sndcfg, char *domain_name)
{

// whole udp packet except ip header and usd_header
    int i;
    int sip;
    int total_packet_len = buffer_size;
    int total_len;
    static int srcip_cnt = 0;

// udp packet with usd_header
    int udp_with_usd_len = total_packet_len - sizeof(IP_HEADER) + sizeof(USD_HEADER);

    char *udp_packet = (char *)malloc( udp_with_usd_len );
    if( NULL == udp_packet )
    {
        fprintf( stderr, "malloc udp packet error: %s\n", strerror(errno) );
        exit(-1);
    }
    memset( udp_packet, 0, udp_with_usd_len );

    IpHeader.h_verlen = (4<<4 | sizeof(IpHeader)/sizeof(unsigned int));
    IpHeader.tos = 0;
    IpHeader.total_len = htons( total_packet_len );
    IpHeader.ident = rand() % 30000 + 9876;
    IpHeader.frag_and_flags = 0x0000;
    IpHeader.ttl = 64;
    IpHeader.proto = IPPROTO_UDP;
    IpHeader.checksum = 0x0000;

// 1.1.1.1 ----------- 250.250.250.250
//    IpHeader.sourceIP = htonl(rand( ) % 4193909242 + 16843009);

    sip = sndcfg->start_sip + srcip_cnt%(sndcfg->end_sip - sndcfg->start_sip);

get_sip_again:    

    for (i = 0; i < sndcfg->exclude_sip_num; i++) {
        if (sip == sndcfg->exclude_sip_list[i]) {
            srcip_cnt++;
            if (sip < sndcfg->end_sip) {
                sip++;
            } else {
                sip = sndcfg->start_sip;
            }
            goto get_sip_again;
        }
    }

    srcip_cnt++;

    IpHeader.sourceIP = htonl(sip);    
    IpHeader.destIP = htonl(sndcfg->targetip);

    UdpHeader.uh_sport = htons(sndcfg->start_sport + outcount%(sndcfg->end_sport - sndcfg->start_sport));    
    UdpHeader.uh_dport = htons(sndcfg->targetport);

    UdpHeader.uh_length = htons(total_packet_len - sizeof(IP_HEADER) );
    UdpHeader.uh_checksum = 0x0000;

    UsdHeader.saddr = IpHeader.sourceIP;
    UsdHeader.daddr = IpHeader.destIP;
    UsdHeader.mbz = 0x00;
    UsdHeader.ptcl = IPPROTO_UDP;
    UsdHeader.udpl = UdpHeader.uh_length;

    DnsHeader.tid = rand() % 40000 + 12345;
    DnsHeader.flags = 0x0001;
    DnsHeader.queries = 0x0100;
    DnsHeader.answers = 0x0000;
    DnsHeader.auth = 0x0000;
    DnsHeader.additional = 0x0000;

    QueryHeader.type = 0x0100;
    QueryHeader.class = 0x0100;

    memcpy( (void*)buffer, (void*)&IpHeader, sizeof(IpHeader) );
    IpHeader.checksum = CheckSum( (unsigned short *) buffer, sizeof(IpHeader) );
    memcpy( (void*)buffer, (void*)&IpHeader, sizeof(IpHeader) );

    memcpy( udp_packet, (void*)&UsdHeader, sizeof(UsdHeader) );

    memcpy( udp_packet+sizeof(UsdHeader), &UdpHeader, sizeof(UdpHeader) );

    memcpy( udp_packet+sizeof(UsdHeader)+sizeof(UdpHeader), &DnsHeader, sizeof(DnsHeader) );

    PaddingQuery( udp_packet+sizeof(UsdHeader)+sizeof(UdpHeader)+sizeof(DnsHeader), domain_name );

    memcpy( udp_packet+sizeof(UsdHeader)+sizeof(UdpHeader)+sizeof(DnsHeader)+strlen(domain_name)+1, ((char*)&QueryHeader)+sizeof(char *), sizeof(QueryHeader)-sizeof(char*) );

    UdpHeader.uh_checksum = CheckSum( (unsigned short *)udp_packet, udp_with_usd_len );
    memcpy( udp_packet+sizeof(UsdHeader), &UdpHeader, sizeof(UdpHeader) );

    memcpy( buffer+sizeof(IpHeader), udp_packet+sizeof(UsdHeader), udp_with_usd_len - sizeof(USD_HEADER) );

    free( udp_packet );
}

void one_pkt_info_show(int outcount, int srcip, int sport, int dstip, int dport, char *domain)
{
    struct in_addr saddr,daddr;
    char sip[64] = {0};
    char dip[64] = {0};    

    memset(&saddr, 0, sizeof(saddr));
    memset(&daddr, 0, sizeof(daddr));

    printf("send dns pkts------------ %d -------------------\n", outcount );

    saddr.s_addr = srcip;
    daddr.s_addr = dstip;
    strncpy(sip, inet_ntoa(saddr), 16);
    strncpy(dip, inet_ntoa(daddr), 16);    
    printf("%s[%d] ==> %s[%d] %s\n\n", sip, sport, dip, dport, domain);    
}

int parse_query_file(FILE *fp, struct send_conf *sndcfg, char *domain_name, int size)
{
    char *p;
    char *token;
    char *saveptr;
    char readline[4096] = {0};

read_again:                                 
    if (fgets(readline, sizeof(readline), fp) != NULL) {
        p = readline;
        while(*p == ' ' || *p == '\t') p++;
        if (*p == '#') {
            goto read_again;
        }

        if ((token = strtok_r(p, " ", &saveptr)) != NULL) {
            strncpy(domain_name, token, size);
            p = NULL;
        }
    } else {
        rewind(fp);
        goto read_again;
    }

}

void Flood(struct send_conf *sndcfg)
{
    int ret;
    int sock;
    int flag = 1;
    char domain_name[1024];
    int packet_buff_len = 2048;
    int total_packet_len;

// sizeof(char *) means the length of "name" field in the query header.
// 2 means, 0x00 and the length of host, 0x03www0x06google0x03com0x00

    char *buffer = (char *)malloc(packet_buff_len);
    if( NULL == buffer )
    {
        fprintf( stderr, "malloc memory for packet error.\n" );
        return;
    }

    struct sockaddr_in  sa;
    memset( &sa, 0, sizeof(struct sockaddr_in) );
    sa.sin_family = AF_INET;
    sa.sin_port = htons(sndcfg->targetport);
    sa.sin_addr.s_addr = htonl(sndcfg->targetip);

    if( (sock = socket(PF_INET, SOCK_RAW, IPPROTO_UDP))  < 0 )
    {
        fprintf( stderr, "create socket error: %s\n", strerror(errno) );
        free(buffer);
        return;
    }

    if( setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (int *)&flag, sizeof(flag)) < 0 )
    {
        fprintf( stderr, "setsockopt error: %s\n", strerror(errno) );
        free(buffer);
        return;
    }

    fp_query = fopen(sndcfg->query_file, "r");
    if (fp_query == NULL) {
        fprintf(stderr, "can not open file: %s\n", sndcfg->query_file);
        return;
    }

    int number = 0;
    if( sleeptime == 0 )
    {
        while( 1 )
        {
            memset( (void *)buffer, 0, sizeof(buffer) );
            memset(domain_name, 0, sizeof(domain_name));
            parse_query_file(fp_query, sndcfg, domain_name, sizeof(domain_name));

            total_packet_len = sizeof(IP_HEADER) + sizeof(UDP_HEADER) + sizeof(DNS_HEADER) + sizeof(QUERY_HEADER) + strlen(domain_name) + 2 - sizeof(char *);
            Init( buffer, total_packet_len, sndcfg, domain_name);

            ret = sendto( sock, buffer, total_packet_len, 0, (struct sockaddr *)&sa, sizeof(struct sockaddr_in) );
            if (ret == -1) {
                fprintf(stderr, "sento error: %s\n", strerror(errno));
                continue;
            }
            outcount ++;
            if (debug_flag) {
                one_pkt_info_show(outcount, IpHeader.sourceIP, ntohs(UdpHeader.uh_sport),
                                  IpHeader.destIP, ntohs(UdpHeader.uh_dport), query_domain);
            }
            if (max_pkts != 0 && outcount >= max_pkts) {
                sig_proc(0);
                exit(0);
            }
        }
    }

    else
    {
        while( 1 )
        {

            memset( (void *)buffer, 0, sizeof(buffer) );
            memset(domain_name, 0, sizeof(domain_name));
            parse_query_file(fp_query, sndcfg, domain_name, sizeof(domain_name));

            total_packet_len = sizeof(IP_HEADER) + sizeof(UDP_HEADER) + sizeof(DNS_HEADER) + sizeof(QUERY_HEADER) + strlen(domain_name) + 2 - sizeof(char *);
            Init( buffer, total_packet_len, sndcfg, domain_name);

            ret = sendto( sock, buffer, total_packet_len, 0, (struct sockaddr *)&sa, sizeof(struct sockaddr_in) );
            if (ret == -1) {
                fprintf(stderr, "sento error: %s\n", strerror(errno));
                continue;
            }

            outcount ++;
            number ++;

            if (debug_flag) {
                one_pkt_info_show(outcount, IpHeader.sourceIP, ntohs(UdpHeader.uh_sport),
                                  IpHeader.destIP, ntohs(UdpHeader.uh_dport), query_domain);
            }

            if (max_pkts != 0 && outcount >= max_pkts) {            
                sig_proc(0);
                exit(0);
            }

            if( number == pkt_then_sleep )
            {
                MySleep( sleeptime );
                number = 0;
            }
        }
    }

    free( buffer );
    return;
}

void sig_proc(int signum)
{
    int end_time = 0;
    char *lang_env;

    end_time=time(NULL);

    lang_env = getenv("LANG");
    if (!lang_env) {
        printf("getenv LANG not Found\n");
        return;
    }

    if (!strncmp(lang_env, "zh_CN.UTF-8", strlen("zh_CN.UTF-8"))) {
        printf("\n ********** 统计信息( %d ) *************\n", signum);
        printf("   总发包数:          %llu\n",outcount);
        printf("   运行时间:        　%llu\n",end_time - starttime);
        printf("   平均每秒发包数: 　 %llu\n",outcount/(end_time - starttime));
        printf(" **************************************\n");
    } else {
        printf("\n ******* statistics( %d ) *************\n", signum);
        printf("   packets sent:          %llu\n",outcount);
        printf("   seconds active:        %llu\n",end_time - starttime);
        printf("   average packet/second: %llu\n",outcount/(end_time - starttime));
        printf(" **************************************\n");        
    }

    if (fp_query) {
        fclose(fp_query);
    }

    exit(1);
}

int usage(void)
{
    char *lang_env;

    lang_env = getenv("LANG");
    if (!lang_env) {
        printf("getenv LANG not Found\n");
        return -1;
    }

    if (!strncmp(lang_env, "zh_CN.UTF-8", strlen("zh_CN.UTF-8"))) {
        fprintf(stderr,"\n%s @config_file <pkt_then_sleep> <sleep_time> <max_pkts> [debug] \n",  "senddns");
        fprintf(stderr, "DNS发包模拟程序\n");
        fprintf(stderr, "参数说明: \n"
                "\t @config_file:      配置文件\n"
                "\t <pkt_then_sleep>:  每次发送的包数后休眠\n"
                "\t <sleep_time>:      休眠时间(微秒)\n"
                "\t <max_pkts>:        发送总包数(0代表无穷大,可通过信号打断退出)\n"
                "\t [debug]:           调试信息输出开关\n"
            );
    } else {
        fprintf(stderr,"\n%s @config_file <pkt_then_sleep> <sleep_time> <max_pkts> [debug] \n",  "senddns");        
        fprintf(stderr, "DNS send packets monitor\n");
        fprintf(stderr, "args note: \n"
                "\t @config_file:      config file\n"                
                "\t <pkt_then_sleep>:  send packets number before sleep interval\n"
                "\t <sleep_time>:      sleep time(microseconds)\n"
                "\t <max_pkts>:        send total packets(0 is enough big, can be signal interrupt then exit)\n"
                "\t [debug]:           debug switch\n"
            );
    }
}

void set_sig( )
{
    signal(SIGHUP,&sig_proc);
    signal(SIGINT,&sig_proc);
    signal(SIGQUIT,&sig_proc);
    signal(SIGILL,&sig_proc);
    signal(SIGABRT,&sig_proc);
    signal(SIGFPE,&sig_proc);
    signal(SIGSEGV,&sig_proc);
    signal(SIGPIPE,&sig_proc);
    signal(SIGALRM,&sig_proc);
    signal(SIGTERM,&sig_proc);
    signal(SIGUSR1,&sig_proc);
    signal(SIGUSR2,&sig_proc);
    signal(SIGCHLD,&sig_proc);
    signal(SIGCONT,&sig_proc);
    signal(SIGTSTP,&sig_proc);
    signal(SIGTTIN,&sig_proc);
    signal(SIGTTOU,&sig_proc);
}


int parse_conf_file(char *conf_name)
{
    int ret;
    int i;
    FILE *fp = NULL;
    char *p = NULL;
    char readline[4096] = {0};
    char *saveptr = NULL;
    char *token;
    int ip;
    int port;
    int threadnum;
    int len;

    conf_name += 1; /* skip @  */
    fp = fopen(conf_name, "r");
    if (fp == NULL) {
        fprintf(stderr, "can not open %s file: %s\n", conf_name, strerror(errno));
        return -1;
    }

    while (fgets(readline, sizeof(readline), fp) != NULL) {
        p = readline;
        while (*p == ' ' || *p == '\t' ) p++;
        if (*p == '#') continue;

        if (!strncmp(p, "--threadnum", strlen("--threadnum"))) {
            p = strchr(p, ' ');
            while (*p == ' ' || *p == '\t' ) p++;
            threadnum = atoi(p);
            if (threadnum <= 0 || threadnum > 32) {
                fprintf(stderr, "--threadnum must be range in [1~32]: %s\n", p);
                return -1;
            }
            send_config.threadnum = threadnum;
        } else if (!strncmp(p, "--start_sip", strlen("--start_sip"))) {
            p = strchr(p, ' ');
            while (*p == ' ' || *p == '\t' ) p++;
            ip = inet_addr(p);
            if (ip == INADDR_NONE) {
                fprintf(stderr, "--start_sip format error: %s\n", p);
                return -1;
            }
            send_config.start_sip = ntohl(ip);

        } else if (!strncmp(p, "--end_sip", strlen("--end_sip"))) {
            p = strchr(p, ' ');
            while (*p == ' ' || *p == '\t' ) p++;
            ip = inet_addr(p);
            if (ip == INADDR_NONE) {
                fprintf(stderr, "--end_sip format error: %s\n", p);
                return -1;
            }
            send_config.end_sip = ntohl(ip);

        } else if (!strncmp(p, "--exclude_sip", strlen("--exclude_sip"))) {
            p = strchr(p, ' ');
            while (*p == ' ' || *p == '\t' ) p++;
            i = 0;
            send_config.exclude_sip_num = 0;
            while ((token = strtok_r(p, " ", &saveptr)) != NULL) {
                ip = inet_addr(token);
                if (ip == INADDR_NONE) {
                    fprintf(stderr, "--exclude_sip format error: %s\n", p);
                    return -1;
                }
                send_config.exclude_sip_num++;
                send_config.exclude_sip_list[i] = ntohl(ip);
                i++;
                p = NULL;                
            }
        } else if (!strncmp(p, "--start_sport", strlen("--start_sport"))) {
            p = strchr(p, ' ');
            while (*p == ' ' || *p == '\t' ) p++;
            port = atoi(p);
            if (port <= 1024) {
                fprintf(stderr, "--start_sport must be big than 1024: %s\n", p);
                return -1;
            }
            send_config.start_sport = atoi(p);

        } else if (!strncmp(p, "--end_sport", strlen("--end_sport"))) {
            p = strchr(p, ' ');
            while (*p == ' ' || *p == '\t' ) p++;
            port = atoi(p);
            if (port > 65535) {
                fprintf(stderr, "--end_sport must be less than 65536: %s\n", p);
                return -1;
            }
            send_config.end_sport = atoi(p);

        } else if (!strncmp(p, "--targetip", strlen("--targetip"))) {
            p = strchr(p, ' ');
            while (*p == ' ' || *p == '\t' ) p++;
            ip = inet_addr(p);
            if (ip == INADDR_NONE) {
                fprintf(stderr, "--targetip format error: %s\n", p);
                return -1;
            }
            send_config.targetip = ntohl(ip);

        } else if (!strncmp(p, "--targetport", strlen("--targetport"))) {
            p = strchr(p, ' ');
            while (*p == ' ' || *p == '\t' ) p++;
            send_config.targetport = atoi(p);

        } else if (!strncmp(p, "--queryfile", strlen("--queryfile"))) {
            p = strchr(p, ' ');
            while (*p == ' ' || *p == '\t' ) p++;
            len = strlen(p);
            if (p[len-1] == '\n') {
                p[len-1] = '\0';
            }
            ret = access(p, F_OK);
            if (ret != 0) {
                fprintf(stderr, "can not access file: %s, ERR: %s\n", p, strerror(errno));
                return -1;
            }
            strncpy(send_config.query_file, p, sizeof(send_config.query_file));
        } 

        memset(readline, 0, sizeof(readline));

    }

    fclose(fp);

    return 0;
}


int main(int argc,char *argv[])
{
    int i;
    int ret;
    char    dst_ip[20] = { 0 };

    if( argc != 5 && argc != 6 )
    {
        usage();
        return -1;
    }

    if (argc == 6 && !strcmp(argv[5], "debug")) {
        debug_flag = 1;
    }

    if (argv[1][0] != '@') {
        usage();
        return -1;
    }

    ret = parse_conf_file(argv[1]);
    if (ret != 0) {
        fprintf(stderr, "parse config file error: %d\n", ret);
        return ret;
    }

    pkt_then_sleep = atoi(argv[2]);
    if( pkt_then_sleep == 0 )
    {
        printf( "pkt_then_sleep error.\n" );
        return -1;
    }

    sleeptime = atoi(argv[3]);
    max_pkts = atoi(argv[4]);     
    starttime = time(NULL);
    while(time(NULL) == starttime) usleep(1000);

    srand((unsigned) time(NULL));

    set_sig( );
    Flood(&send_config);

    return 0;
}